FX_BOOL considered harmful, part 2.

Fully automatic change, execpt for cleanup in fx_system.h

R=thestig@chromium.org

Review URL: https://codereview.chromium.org/1254703002 .

140 files changed, 4764 insertions, 4764 deletions

diff --git a/core/src/fdrm/crypto/fx_crypt.cpp b/core/src/fdrm/crypto/fx_crypt.cpp
index 83a420ad38..f19445f8f2 100644
--- a/core/src/fdrm/crypto/fx_crypt.cpp
+++ b/core/src/fdrm/crypto/fx_crypt.cpp
@@ -249,8 +249,8 @@ void CRYPT_MD5Generate(const uint8_t* input, FX_DWORD length, uint8_t digest[16]
     CRYPT_MD5Update(&ctx, input, length);
     CRYPT_MD5Finish(&ctx, digest);
 }
-static FX_BOOL (*g_PubKeyDecryptor)(const uint8_t* pData, FX_DWORD size, uint8_t* data_buf, FX_DWORD& data_len) = NULL;
-void CRYPT_SetPubKeyDecryptor(FX_BOOL (*func)(const uint8_t* pData, FX_DWORD size, uint8_t* data_buf, FX_DWORD& data_len))
+static bool (*g_PubKeyDecryptor)(const uint8_t* pData, FX_DWORD size, uint8_t* data_buf, FX_DWORD& data_len) = NULL;
+void CRYPT_SetPubKeyDecryptor(bool (*func)(const uint8_t* pData, FX_DWORD size, uint8_t* data_buf, FX_DWORD& data_len))
 {
     g_PubKeyDecryptor = func;
 }
diff --git a/core/src/fdrm/crypto/fx_crypt_aes.cpp b/core/src/fdrm/crypto/fx_crypt_aes.cpp
index 4bd87105aa..9f142226da 100644
--- a/core/src/fdrm/crypto/fx_crypt_aes.cpp
+++ b/core/src/fdrm/crypto/fx_crypt_aes.cpp
@@ -988,7 +988,7 @@ static void aes_encrypt_cbc(unsigned char *dest, const unsigned char *src, int l
     }
     FXSYS_memcpy(ctx->iv, iv, sizeof(iv));
 }
-void CRYPT_AESSetKey(void* context, FX_DWORD blocklen, const uint8_t* key, FX_DWORD keylen, FX_BOOL bEncrypt)
+void CRYPT_AESSetKey(void* context, FX_DWORD blocklen, const uint8_t* key, FX_DWORD keylen, bool bEncrypt)
 {
     aes_setup((AESContext*)context, blocklen, key, keylen);
 }
diff --git a/core/src/fdrm/crypto/fx_crypt_sha.cpp b/core/src/fdrm/crypto/fx_crypt_sha.cpp
index b22348a03c..de1ec08d3d 100644
--- a/core/src/fdrm/crypto/fx_crypt_sha.cpp
+++ b/core/src/fdrm/crypto/fx_crypt_sha.cpp
@@ -405,7 +405,7 @@ uint64_t FX_ato64i(const FX_CHAR* str)
         } else if (str[i] >= 'A' && str[i] <= 'F') {
             ret |= (str[i] - 'A' + 10) & 0xFF;
         } else {
-            FXSYS_assert(FALSE);
+            FXSYS_assert(false);
         }
     }
     return ret;
diff --git a/core/src/fpdfapi/fpdf_basic_module.cpp b/core/src/fpdfapi/fpdf_basic_module.cpp
index 03cfd66afb..83034af640 100644
--- a/core/src/fpdfapi/fpdf_basic_module.cpp
+++ b/core/src/fpdfapi/fpdf_basic_module.cpp
@@ -44,14 +44,14 @@ CPDF_ModuleMgr::~CPDF_ModuleMgr()
 {
 }
 
-void CPDF_ModuleMgr::SetDownloadCallback(FX_BOOL (*callback)(const FX_CHAR* module_name))
+void CPDF_ModuleMgr::SetDownloadCallback(bool (*callback)(const FX_CHAR* module_name))
 {
     m_pDownloadCallback = callback;
 }
-FX_BOOL CPDF_ModuleMgr::DownloadModule(const FX_CHAR* module_name)
+bool CPDF_ModuleMgr::DownloadModule(const FX_CHAR* module_name)
 {
     if (m_pDownloadCallback == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pDownloadCallback(module_name);
 }
diff --git a/core/src/fpdfapi/fpdf_edit/editint.h b/core/src/fpdfapi/fpdf_edit/editint.h
index 4aec32a49a..bc4c72aff9 100644
--- a/core/src/fpdfapi/fpdf_edit/editint.h
+++ b/core/src/fpdfapi/fpdf_edit/editint.h
@@ -12,7 +12,7 @@ class CPDF_ObjectStream
 public:
     CPDF_ObjectStream();
 
-    FX_BOOL				Start();
+    bool				Start();
 
     int32_t			CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Object *pObj);
     int32_t			CompressIndirectObject(FX_DWORD dwObjNum, const uint8_t* pBuffer, FX_DWORD dwSize);
@@ -34,15 +34,15 @@ public:
 
     CPDF_XRefStream();
 
-    FX_BOOL				Start();
+    bool				Start();
 
     int32_t			CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Object *pObj, CPDF_Creator *pCreator);
 
     int32_t			CompressIndirectObject(FX_DWORD dwObjNum, const uint8_t* pBuffer, FX_DWORD dwSize, CPDF_Creator *pCreator);
 
-    FX_BOOL				End(CPDF_Creator *pCreator, FX_BOOL bEOF = FALSE);
-    FX_BOOL				AddObjectNumberToIndexArray(FX_DWORD objnum);
-    FX_BOOL				EndXRefStream(CPDF_Creator* pCreator);
+    bool				End(CPDF_Creator *pCreator, bool bEOF = false);
+    bool				AddObjectNumberToIndexArray(FX_DWORD objnum);
+    bool				EndXRefStream(CPDF_Creator* pCreator);
 
 
     CFX_DWordArray		m_IndexArray;
@@ -51,8 +51,8 @@ public:
     FX_DWORD			m_dwTempObjNum;
 
 protected:
-    int32_t			EndObjectStream(CPDF_Creator *pCreator, FX_BOOL bEOF = TRUE);
-    FX_BOOL				GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF);
+    int32_t			EndObjectStream(CPDF_Creator *pCreator, bool bEOF = true);
+    bool				GenerateXRefStream(CPDF_Creator* pCreator, bool bEOF);
     int32_t			m_iSeg;
     CPDF_ObjectStream	m_ObjStream;
     CFX_ByteTextBuf		m_Buffer;
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
index 65f78dab13..b84936c273 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_content.cpp
@@ -28,10 +28,10 @@ CPDF_PageContentGenerate::CPDF_PageContentGenerate(CPDF_Page* pPage) : m_pPage(p
 CPDF_PageContentGenerate::~CPDF_PageContentGenerate()
 {
 }
-FX_BOOL CPDF_PageContentGenerate::InsertPageObject(CPDF_PageObject* pPageObject)
+bool CPDF_PageContentGenerate::InsertPageObject(CPDF_PageObject* pPageObject)
 {
     if (!pPageObject) {
-        return FALSE;
+        return false;
     }
     return m_pageObjects.Add(pPageObject);
 }
@@ -51,7 +51,7 @@ void CPDF_PageContentGenerate::GenerateContent()
         pPageDict->RemoveAt("Contents");
     }
     CPDF_Stream* pStream = new CPDF_Stream(NULL, 0, NULL);
-    pStream->SetData(buf.GetBuffer(), buf.GetLength(), FALSE, FALSE);
+    pStream->SetData(buf.GetBuffer(), buf.GetLength(), false, false);
     m_pDocument->AddIndirectObject(pStream);
     pPageDict->SetAtReference("Contents", m_pDocument, pStream->GetObjNum());
 }
@@ -158,7 +158,7 @@ void CPDF_PageContentGenerate::TransformContent(CFX_Matrix& matrix)
         ProcessForm(buf, contentStream.GetData(), contentStream.GetSize(), matrix);
     }
     CPDF_Stream* pStream = new CPDF_Stream(NULL, 0, NULL);
-    pStream->SetData(buf.GetBuffer(), buf.GetLength(), FALSE, FALSE);
+    pStream->SetData(buf.GetBuffer(), buf.GetLength(), false, false);
     m_pDocument->AddIndirectObject(pStream);
     m_pPage->m_pFormDict->SetAtReference("Contents", m_pDocument, pStream->GetObjNum());
 }
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
index 22826a3609..b197b25979 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_create.cpp
@@ -13,7 +13,7 @@
 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_data, uint8_t*& dest_buf, FX_DWORD& dest_size);
 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, int predictor, int Colors, int BitsPerComponent, int Columns,
                         uint8_t*& dest_buf, FX_DWORD& dest_size);
-extern FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict);
+extern bool IsSignatureDict(const CPDF_Dictionary* pDict);
 int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *pFile, FX_FILESIZE& offset)
 {
     int32_t len = 0;
@@ -43,7 +43,7 @@ int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *
             break;
         case PDFOBJ_STRING: {
                 CFX_ByteString str = pObj->GetString();
-                FX_BOOL bHex = ((CPDF_String*)pObj)->IsHex();
+                bool bHex = ((CPDF_String*)pObj)->IsHex();
                 if ((len = pFile->AppendString(PDF_EncodeString(str, bHex))) < 0) {
                     return -1;
                 }
@@ -156,7 +156,7 @@ int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *
                 }
                 offset += 8;
                 CPDF_StreamAcc acc;
-                acc.LoadAllData(p, TRUE);
+                acc.LoadAllData(p, true);
                 if (pFile->AppendBlock(acc.GetData(), acc.GetSize()) < 0) {
                     return -1;
                 }
@@ -168,12 +168,12 @@ int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *
                 break;
             }
         default:
-            ASSERT(FALSE);
+            ASSERT(false);
             break;
     }
     return 1;
 }
-int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument, CFX_FileBufferArchive* pFile, CPDF_Array* pIDArray, FX_BOOL bCompress)
+int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument, CFX_FileBufferArchive* pFile, CPDF_Array* pIDArray, bool bCompress)
 {
     FX_FILESIZE offset = 0;
     int32_t len = 0;
@@ -285,10 +285,10 @@ int32_t PDF_CreatorWriteEncrypt(const CPDF_Dictionary* pEncryptDict, FX_DWORD dw
     offset += len + 6;
     return offset;
 }
-FX_BOOL PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2, FX_DWORD* pBuffer)
+bool PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2, FX_DWORD* pBuffer)
 {
     if (!pBuffer) {
-        return FALSE;
+        return false;
     }
     void* pContext = FX_Random_MT_Start(dwSeed1);
     int32_t i = 0;
@@ -301,21 +301,21 @@ FX_BOOL PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2, FX_DWORD* pBuffer
         *pBuffer++ = FX_Random_MT_Generate(pContext);
     }
     FX_Random_MT_Close(pContext);
-    return TRUE;
+    return true;
 }
 class CPDF_FlateEncoder
 {
 public:
     CPDF_FlateEncoder();
     ~CPDF_FlateEncoder();
-    FX_BOOL		Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
-    FX_BOOL		Initialize(const uint8_t* pBuffer, FX_DWORD size, FX_BOOL bFlateEncode, FX_BOOL bXRefStream = FALSE);
+    bool		Initialize(CPDF_Stream* pStream, bool bFlateEncode);
+    bool		Initialize(const uint8_t* pBuffer, FX_DWORD size, bool bFlateEncode, bool bXRefStream = false);
     void		CloneDict();
     uint8_t*			m_pData;
     FX_DWORD			m_dwSize;
     CPDF_Dictionary*	m_pDict;
-    FX_BOOL				m_bCloned;
-    FX_BOOL				m_bNewData;
+    bool				m_bCloned;
+    bool				m_bNewData;
     CPDF_StreamAcc		m_Acc;
 };
 CPDF_FlateEncoder::CPDF_FlateEncoder()
@@ -323,19 +323,19 @@ CPDF_FlateEncoder::CPDF_FlateEncoder()
     m_pData = NULL;
     m_dwSize = 0;
     m_pDict = NULL;
-    m_bCloned = FALSE;
-    m_bNewData = FALSE;
+    m_bCloned = false;
+    m_bNewData = false;
 }
 void CPDF_FlateEncoder::CloneDict()
 {
     if (!m_bCloned) {
         m_pDict = (CPDF_Dictionary*)m_pDict->Clone();
-        m_bCloned = TRUE;
+        m_bCloned = true;
     }
 }
-FX_BOOL CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode)
+bool CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream, bool bFlateEncode)
 {
-    m_Acc.LoadAllData(pStream, TRUE);
+    m_Acc.LoadAllData(pStream, true);
     if ((pStream && pStream->GetDict() && pStream->GetDict()->KeyExist("Filter")) || !bFlateEncode) {
         if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) {
             CPDF_StreamAcc destAcc;
@@ -344,40 +344,40 @@ FX_BOOL CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode
             m_pData = (uint8_t*)destAcc.DetachData();
             m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone();
             m_pDict->RemoveAt(FX_BSTRC("Filter"));
-            m_bNewData = TRUE;
-            m_bCloned = TRUE;
+            m_bNewData = true;
+            m_bCloned = true;
         } else {
             m_pData = (uint8_t*)m_Acc.GetData();
             m_dwSize = m_Acc.GetSize();
             m_pDict = pStream->GetDict();
         }
-        return TRUE;
+        return true;
     }
     m_pData = NULL;
     m_dwSize = 0;
-    m_bNewData = TRUE;
-    m_bCloned = TRUE;
+    m_bNewData = true;
+    m_bCloned = true;
     ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize);
     m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone();
     m_pDict->SetAtInteger("Length", m_dwSize);
     m_pDict->SetAtName("Filter", "FlateDecode");
     m_pDict->RemoveAt("DecodeParms");
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer, FX_DWORD size, FX_BOOL bFlateEncode, FX_BOOL bXRefStream)
+bool CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer, FX_DWORD size, bool bFlateEncode, bool bXRefStream)
 {
     if (!bFlateEncode) {
         m_pData = (uint8_t*)pBuffer;
         m_dwSize = size;
-        return TRUE;
+        return true;
     }
-    m_bNewData = TRUE;
+    m_bNewData = true;
     if (bXRefStream) {
         ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize);
     } else {
         ::FlateEncode(pBuffer, size, m_pData, m_dwSize);
     }
-    return TRUE;
+    return true;
 }
 CPDF_FlateEncoder::~CPDF_FlateEncoder()
 {
@@ -393,33 +393,33 @@ class CPDF_Encryptor
 public:
     CPDF_Encryptor();
     ~CPDF_Encryptor();
-    FX_BOOL		Initialize(CPDF_CryptoHandler* pHandler, int objnum, uint8_t* src_data, FX_DWORD src_size);
+    bool		Initialize(CPDF_CryptoHandler* pHandler, int objnum, uint8_t* src_data, FX_DWORD src_size);
     uint8_t*			m_pData;
     FX_DWORD			m_dwSize;
-    FX_BOOL				m_bNewBuf;
+    bool				m_bNewBuf;
 };
 CPDF_Encryptor::CPDF_Encryptor()
 {
     m_pData = NULL;
     m_dwSize = 0;
-    m_bNewBuf = FALSE;
+    m_bNewBuf = false;
 }
-FX_BOOL CPDF_Encryptor::Initialize(CPDF_CryptoHandler* pHandler, int objnum, uint8_t* src_data, FX_DWORD src_size)
+bool CPDF_Encryptor::Initialize(CPDF_CryptoHandler* pHandler, int objnum, uint8_t* src_data, FX_DWORD src_size)
 {
     if (src_size == 0) {
-        return TRUE;
+        return true;
     }
     if (pHandler == NULL) {
         m_pData = (uint8_t*)src_data;
         m_dwSize = src_size;
-        m_bNewBuf = FALSE;
-        return TRUE;
+        m_bNewBuf = false;
+        return true;
     }
     m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size);
     m_pData = FX_Alloc(uint8_t, m_dwSize);
     pHandler->EncryptContent(objnum, 0, src_data, src_size, m_pData, m_dwSize);
-    m_bNewBuf = TRUE;
-    return TRUE;
+    m_bNewBuf = true;
+    return true;
 }
 CPDF_Encryptor::~CPDF_Encryptor()
 {
@@ -432,14 +432,14 @@ CPDF_ObjectStream::CPDF_ObjectStream()
     , m_index(0)
 {
 }
-FX_BOOL CPDF_ObjectStream::Start()
+bool CPDF_ObjectStream::Start()
 {
     m_ObjNumArray.RemoveAll();
     m_OffsetArray.RemoveAll();
     m_Buffer.Clear();
     m_dwObjNum = 0;
     m_index = 0;
-    return TRUE;
+    return true;
 }
 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Object *pObj)
 {
@@ -547,12 +547,12 @@ CPDF_XRefStream::CPDF_XRefStream()
     , m_iSeg(0)
 {
 }
-FX_BOOL CPDF_XRefStream::Start()
+bool CPDF_XRefStream::Start()
 {
     m_IndexArray.RemoveAll();
     m_Buffer.Clear();
     m_iSeg = 0;
-    return TRUE;
+    return true;
 }
 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Object *pObj, CPDF_Creator *pCreator)
 {
@@ -578,7 +578,7 @@ int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const uint8_t
     }
     return EndObjectStream(pCreator);
 }
-static void _AppendIndex0(CFX_ByteTextBuf& buffer, FX_BOOL bFirstObject =  TRUE)
+static void _AppendIndex0(CFX_ByteTextBuf& buffer, bool bFirstObject =  true)
 {
     buffer.AppendByte(0);
     buffer.AppendByte(0);
@@ -613,7 +613,7 @@ static void _AppendIndex2(CFX_ByteTextBuf& buffer, FX_DWORD objnum, int32_t inde
     buffer.AppendByte(FX_GETBYTEOFFSET8(index));
     buffer.AppendByte(FX_GETBYTEOFFSET0(index));
 }
-int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, FX_BOOL bEOF)
+int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, bool bEOF)
 {
     FX_FILESIZE objOffset = 0;
     if (bEOF) {
@@ -644,7 +644,7 @@ int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, FX_BOOL bEOF)
                     _AppendIndex2(m_Buffer, dwObjStmNum, index++);
                 }
             } else {
-                _AppendIndex0(m_Buffer, FALSE);
+                _AppendIndex0(m_Buffer, false);
             }
         }
         if (iSize > 0 && bEOF) {
@@ -682,12 +682,12 @@ int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, FX_BOOL bEOF)
     }
     return 1;
 }
-FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF)
+bool CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, bool bEOF)
 {
     FX_FILESIZE offset_tmp = pCreator->m_Offset;
     FX_DWORD objnum = ++pCreator->m_dwLastObjNum;
     CFX_FileBufferArchive *pFile = &pCreator->m_File;
-    FX_BOOL bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
+    bool bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
     if (bIncremental) {
         AddObjectNumberToIndexArray(objnum);
     } else {
@@ -696,7 +696,7 @@ FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF
             if (offset) {
                 _AppendIndex1(m_Buffer, *offset);
             } else {
-                _AppendIndex0(m_Buffer, FALSE);
+                _AppendIndex0(m_Buffer, false);
             }
         }
     }
@@ -704,49 +704,49 @@ FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF
     FX_FILESIZE &offset = pCreator->m_Offset;
     int32_t len = pFile->AppendDWord(objnum);
     if (len < 0) {
-        return FALSE;
+        return false;
     }
     offset += len;
     if ((len = pFile->AppendString(FX_BSTRC(" 0 obj\r\n<</Type /XRef/W[1 4 2]/Index["))) < 0) {
-        return FALSE;
+        return false;
     }
     offset += len;
     if (!bIncremental) {
         if ((len = pFile->AppendDWord(0)) < 0) {
-            return FALSE;
+            return false;
         }
         if ((len = pFile->AppendString(FX_BSTRC(" "))) < 0) {
-            return FALSE;
+            return false;
         }
         offset += len + 1;
         if ((len = pFile->AppendDWord(objnum + 1)) < 0) {
-            return FALSE;
+            return false;
         }
         offset += len;
     } else {
         int32_t iSeg = m_IndexArray.GetSize() / 2;
         for (int32_t i = 0; i < iSeg; i++) {
             if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2))) < 0) {
-                return FALSE;
+                return false;
             }
             if (pFile->AppendString(FX_BSTRC(" ")) < 0) {
-                return FALSE;
+                return false;
             }
             offset += len + 1;
             if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2 + 1))) < 0) {
-                return FALSE;
+                return false;
             }
             if (pFile->AppendString(FX_BSTRC(" ")) < 0) {
-                return FALSE;
+                return false;
             }
             offset += len + 1;
         }
     }
     if (pFile->AppendString(FX_BSTRC("]/Size ")) < 0) {
-        return FALSE;
+        return false;
     }
     if ((len = pFile->AppendDWord(objnum + 1)) < 0) {
-        return FALSE;
+        return false;
     }
     offset += len + 7;
     if (m_PrevOffset > 0) {
@@ -762,26 +762,26 @@ FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF
         }
         offset += len + 6;
     }
-    FX_BOOL bPredictor = TRUE;
+    bool bPredictor = true;
     CPDF_FlateEncoder encoder;
     encoder.Initialize(m_Buffer.GetBuffer(), m_Buffer.GetLength(), pCreator->m_bCompress, bPredictor);
     if (pCreator->m_bCompress) {
         if (pFile->AppendString(FX_BSTRC("/Filter /FlateDecode")) < 0) {
-            return FALSE;
+            return false;
         }
         offset += 20;
         if (bPredictor) {
             if ((len = pFile->AppendString(FX_BSTRC("/DecodeParms<</Columns 7/Predictor 12>>"))) < 0) {
-                return FALSE;
+                return false;
             }
             offset += len;
         }
     }
     if (pFile->AppendString(FX_BSTRC("/Length ")) < 0) {
-        return FALSE;
+        return false;
     }
     if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0) {
-        return FALSE;
+        return false;
     }
     offset += len + 8;
     if (bEOF) {
@@ -801,27 +801,27 @@ FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF
         }
     }
     if ((len = pFile->AppendString(FX_BSTRC(">>stream\r\n"))) < 0) {
-        return FALSE;
+        return false;
     }
     offset += len;
     if (pFile->AppendBlock(encoder.m_pData, encoder.m_dwSize) < 0) {
-        return FALSE;
+        return false;
     }
     if ((len = pFile->AppendString(FX_BSTRC("\r\nendstream\r\nendobj\r\n"))) < 0) {
-        return FALSE;
+        return false;
     }
     offset += encoder.m_dwSize + len;
     m_PrevOffset = offset_tmp;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_XRefStream::End(CPDF_Creator *pCreator, FX_BOOL bEOF )
+bool CPDF_XRefStream::End(CPDF_Creator *pCreator, bool bEOF )
 {
     if (EndObjectStream(pCreator, bEOF) < 0) {
-        return FALSE;
+        return false;
     }
     return GenerateXRefStream(pCreator, bEOF);
 }
-FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator)
+bool CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator)
 {
     if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
         _AppendIndex0(m_Buffer);
@@ -830,7 +830,7 @@ FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator)
             if (offset) {
                 _AppendIndex1(m_Buffer, *offset);
             } else {
-                _AppendIndex0(m_Buffer, FALSE);
+                _AppendIndex0(m_Buffer, false);
             }
         }
     } else {
@@ -843,9 +843,9 @@ FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator)
             }
         }
     }
-    return GenerateXRefStream(pCreator, FALSE);
+    return GenerateXRefStream(pCreator, false);
 }
-FX_BOOL CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum)
+bool CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum)
 {
     int32_t iSize = m_IndexArray.GetSize();
     if (iSize == 0) {
@@ -862,13 +862,13 @@ FX_BOOL CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum)
             m_IndexArray.Add(1);
         }
     }
-    return TRUE;
+    return true;
 }
 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc)
 {
     m_pDocument = pDoc;
     m_pParser = (CPDF_Parser*)pDoc->m_pParser;
-    m_bCompress = TRUE;
+    m_bCompress = true;
     if (m_pParser) {
         m_pEncryptDict = m_pParser->GetEncryptDict();
         m_pCryptoHandler = m_pParser->GetCryptoHandler();
@@ -876,11 +876,11 @@ CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc)
         m_pEncryptDict = NULL;
         m_pCryptoHandler = NULL;
     }
-    m_bSecurityChanged = FALSE;
-    m_bStandardSecurity = FALSE;
+    m_bSecurityChanged = false;
+    m_bStandardSecurity = false;
     m_pMetadata = NULL;
-    m_bEncryptCloned = FALSE;
-    m_bEncryptMetadata = FALSE;
+    m_bEncryptCloned = false;
+    m_bEncryptMetadata = false;
     m_Offset = 0;
     m_iStage = -1;
     m_dwFlags = 0;
@@ -892,7 +892,7 @@ CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc)
     m_pIDArray = NULL;
     m_FileVersion = 0;
     m_dwEnryptObjNum = 0;
-    m_bNewCrypto = FALSE;
+    m_bNewCrypto = false;
 }
 CPDF_Creator::~CPDF_Creator()
 {
@@ -903,10 +903,10 @@ CPDF_Creator::~CPDF_Creator()
     }
     Clear();
 }
-static FX_BOOL _IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag)
+static bool _IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag)
 {
     if (!(flag & FPDFCREATE_INCREMENTAL)) {
-        return FALSE;
+        return false;
     }
     int32_t iSize = pXRef->m_IndexArray.GetSize() / 2;
     int32_t iCount = 0;
@@ -1001,7 +1001,7 @@ int32_t CPDF_Creator::AppendObjectNumberToXRef(FX_DWORD objnum)
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream, FX_DWORD objnum, CPDF_CryptoHandler* pCrypto)
 {
     CPDF_FlateEncoder encoder;
-    encoder.Initialize((CPDF_Stream*)pStream, pStream == m_pMetadata ? FALSE : m_bCompress);
+    encoder.Initialize((CPDF_Stream*)pStream, pStream == m_pMetadata ? false : m_bCompress);
     CPDF_Encryptor encryptor;
     if(!encryptor.Initialize(pCrypto, objnum, encoder.m_pData, encoder.m_dwSize)) {
         return -1;
@@ -1067,7 +1067,7 @@ int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj)
     }
     return WriteIndirectObj(pObj->GetObjNum(), pObj);
 }
-int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, FX_BOOL bEncrypt)
+int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, bool bEncrypt)
 {
     int32_t len = 0;
     if (pObj == NULL) {
@@ -1096,7 +1096,7 @@ int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, F
             break;
         case PDFOBJ_STRING: {
                 CFX_ByteString str = pObj->GetString();
-                FX_BOOL bHex = ((CPDF_String*)pObj)->IsHex();
+                bool bHex = ((CPDF_String*)pObj)->IsHex();
                 if (m_pCryptoHandler == NULL || !bEncrypt) {
                     CFX_ByteString content = PDF_EncodeString(str, bHex);
                     if ((len = m_File.AppendString(content)) < 0) {
@@ -1206,10 +1206,10 @@ int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, F
                 }
                 m_Offset += 2;
                 CPDF_Dictionary* p = (CPDF_Dictionary*)pObj;
-                FX_BOOL bSignDict = IsSignatureDict(p);
+                bool bSignDict = IsSignatureDict(p);
                 FX_POSITION pos = p->GetStartPos();
                 while (pos) {
-                    FX_BOOL bSignValue = FALSE;
+                    bool bSignValue = false;
                     CFX_ByteString key;
                     CPDF_Object* pValue = p->GetNextElement(pos, key);
                     if (m_File.AppendString(FX_BSTRC("/")) < 0) {
@@ -1220,7 +1220,7 @@ int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, F
                     }
                     m_Offset += len + 1;
                     if (bSignDict && key == FX_BSTRC("Contents")) {
-                        bSignValue = TRUE;
+                        bSignValue = true;
                     }
                     if (pValue->GetObjNum()) {
                         if (m_File.AppendString(FX_BSTRC(" ")) < 0) {
@@ -1255,8 +1255,8 @@ int32_t CPDF_Creator::WriteOldIndirectObject(FX_DWORD objnum)
     }
     m_ObjectOffset[objnum] = m_Offset;
     void* valuetemp = NULL;
-    FX_BOOL bExistInMap = m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, valuetemp);
-    FX_BOOL bObjStm = (m_pParser->m_V5Type[objnum] == 2) && m_pEncryptDict && !m_pXRefStream;
+    bool bExistInMap = m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, valuetemp);
+    bool bObjStm = (m_pParser->m_V5Type[objnum] == 2) && m_pEncryptDict && !m_pXRefStream;
     if(m_pParser->m_bVersionUpdated || m_bSecurityChanged || bExistInMap || bObjStm) {
         CPDF_Object* pObj = m_pDocument->GetIndirectObject(objnum);
         if (pObj == NULL) {
@@ -1334,7 +1334,7 @@ int32_t CPDF_Creator::WriteOldObjs(IFX_Pause *pPause)
     }
     return 0;
 }
-int32_t CPDF_Creator::WriteNewObjs(FX_BOOL bIncremental, IFX_Pause *pPause)
+int32_t CPDF_Creator::WriteNewObjs(bool bIncremental, IFX_Pause *pPause)
 {
     int32_t iCount = m_NewObjNumArray.GetSize();
     int32_t index = (int32_t)(uintptr_t)m_Pos;
@@ -1385,8 +1385,8 @@ void CPDF_Creator::InitOldObjNumOffsets()
 }
 void CPDF_Creator::InitNewObjNumOffsets()
 {
-    FX_BOOL bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
-    FX_BOOL bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0;
+    bool bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
+    bool bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0;
     FX_DWORD nOldSize = m_pParser ? m_pParser->m_CrossRef.GetSize() : 0;
     FX_POSITION pos = m_pDocument->m_IndirectObjs.GetStartPosition();
     while (pos) {
@@ -1414,7 +1414,7 @@ void CPDF_Creator::InitNewObjNumOffsets()
     }
     int32_t i = 0;
     FX_DWORD dwStartObjNum = 0;
-    FX_BOOL bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0;
+    bool bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0;
     while (i < iCount) {
         dwStartObjNum = m_NewObjNumArray.ElementAt(i);
         if ((bIncremental && (bNoOriginal || bCrossRefValid)) || !m_ObjectOffset.GetPtrAt(dwStartObjNum)) {
@@ -1427,10 +1427,10 @@ void CPDF_Creator::InitNewObjNumOffsets()
     }
     FX_DWORD dwLastObjNum = dwStartObjNum;
     i++;
-    FX_BOOL bNewStart = FALSE;
+    bool bNewStart = false;
     for (; i < iCount; i++) {
         FX_DWORD dwCurObjNum = m_NewObjNumArray.ElementAt(i);
-        FX_BOOL bExist = (dwCurObjNum < nOldSize && m_ObjectOffset.GetPtrAt(dwCurObjNum) != NULL);
+        bool bExist = (dwCurObjNum < nOldSize && m_ObjectOffset.GetPtrAt(dwCurObjNum) != NULL);
         if (bExist || dwCurObjNum - dwLastObjNum > 1) {
             if (!bNewStart) {
                 m_ObjectOffset.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum + 1);
@@ -1546,7 +1546,7 @@ int32_t CPDF_Creator::WriteDoc_Stage1(IFX_Pause *pPause)
         if ((m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0 && m_pParser->GetLastXRefOffset() == 0) {
             InitOldObjNumOffsets();
             FX_DWORD dwEnd = m_pParser->GetLastObjNum();
-            FX_BOOL bObjStm = (m_dwFlags & FPDFCREATE_OBJECTSTREAM) != 0;
+            bool bObjStm = (m_dwFlags & FPDFCREATE_OBJECTSTREAM) != 0;
             for (FX_DWORD objnum = 0; objnum <= dwEnd; objnum++) {
                 if (m_pParser->m_V5Type[objnum] == 0 || m_pParser->m_V5Type[objnum] == 255) {
                     continue;
@@ -1622,7 +1622,7 @@ int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause *pPause)
     if (m_iStage == 80) {
         m_XrefStart = m_Offset;
         if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
-            m_pXRefStream->End(this, TRUE);
+            m_pXRefStream->End(this, true);
             m_XrefStart = m_pXRefStream->m_PrevOffset;
             m_iStage = 90;
         } else if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 || !m_pParser->IsXRefStream()) {
@@ -1765,7 +1765,7 @@ int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause *pPause)
 {
     FXSYS_assert(m_iStage >= 90);
     if ((m_dwFlags & FPDFCREATE_OBJECTSTREAM) == 0) {
-        FX_BOOL bXRefStream = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser->IsXRefStream();
+        bool bXRefStream = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser->IsXRefStream();
         if (!bXRefStream) {
             if (m_File.AppendString(FX_BSTRC("trailer\r\n<<")) < 0) {
                 return -1;
@@ -1976,39 +1976,39 @@ void CPDF_Creator::Clear()
         m_pIDArray = NULL;
     }
 }
-FX_BOOL CPDF_Creator::Create(const FX_CHAR* filename, FX_DWORD flags)
+bool CPDF_Creator::Create(const FX_CHAR* filename, FX_DWORD flags)
 {
     if (!m_File.AttachFile(filename)) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL bRet = Create(flags);
+    bool bRet = Create(flags);
     if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) {
         Clear();
     }
     return bRet;
 }
-FX_BOOL CPDF_Creator::Create(const FX_WCHAR* filename, FX_DWORD flags)
+bool CPDF_Creator::Create(const FX_WCHAR* filename, FX_DWORD flags)
 {
     if (!m_File.AttachFile(filename)) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL bRet = Create(flags);
+    bool bRet = Create(flags);
     if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) {
         Clear();
     }
     return bRet;
 }
-FX_BOOL CPDF_Creator::Create(IFX_StreamWrite* pFile, FX_DWORD flags)
+bool CPDF_Creator::Create(IFX_StreamWrite* pFile, FX_DWORD flags)
 {
     if (!pFile) {
-        return FALSE;
+        return false;
     }
-    if (!m_File.AttachFile(pFile, FALSE)) {
-        return FALSE;
+    if (!m_File.AttachFile(pFile, false)) {
+        return false;
     }
     return Create(flags);
 }
-FX_BOOL CPDF_Creator::Create(FX_DWORD flags)
+bool CPDF_Creator::Create(FX_DWORD flags)
 {
     m_dwFlags = flags;
     m_iStage = 0;
@@ -2019,14 +2019,14 @@ FX_BOOL CPDF_Creator::Create(FX_DWORD flags)
     m_NewObjNumArray.RemoveAll();
     InitID();
     if (flags & FPDFCREATE_PROGRESSIVE) {
-        return TRUE;
+        return true;
     }
     return Continue(NULL) > -1;
 }
-void CPDF_Creator::InitID(FX_BOOL bDefault )
+void CPDF_Creator::InitID(bool bDefault )
 {
     CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL;
-    FX_BOOL bNewId = !m_pIDArray;
+    bool bNewId = !m_pIDArray;
     if (!m_pIDArray) {
         FX_DWORD* pBuffer = NULL;
         m_pIDArray = CPDF_Array::Create();
@@ -2037,7 +2037,7 @@ void CPDF_Creator::InitID(FX_BOOL bDefault )
             pBuffer = FX_Alloc(FX_DWORD, 4);
             PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffer);
             CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD));
-            m_pIDArray->Add(CPDF_String::Create(bsBuffer, TRUE), m_pDocument);
+            m_pIDArray->Add(CPDF_String::Create(bsBuffer, true), m_pDocument);
         }
         if (pBuffer) {
             FX_Free(pBuffer);
@@ -2055,7 +2055,7 @@ void CPDF_Creator::InitID(FX_BOOL bDefault )
         FX_DWORD* pBuffer = FX_Alloc(FX_DWORD, 4);
         PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffer);
         CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD));
-        m_pIDArray->Add(CPDF_String::Create(bsBuffer, TRUE), m_pDocument);
+        m_pIDArray->Add(CPDF_String::Create(bsBuffer, true), m_pDocument);
         FX_Free(pBuffer);
         return;
     }
@@ -2071,8 +2071,8 @@ void CPDF_Creator::InitID(FX_BOOL bDefault )
             }
             m_pCryptoHandler = new CPDF_StandardCryptoHandler;
             m_pCryptoHandler->Init(m_pEncryptDict, &handler);
-            m_bNewCrypto = TRUE;
-            m_bSecurityChanged = TRUE;
+            m_bNewCrypto = true;
+            m_bSecurityChanged = true;
         }
     }
 }
@@ -2103,18 +2103,18 @@ int32_t CPDF_Creator::Continue(IFX_Pause *pPause)
     }
     return m_iStage;
 }
-FX_BOOL CPDF_Creator::SetFileVersion(int32_t fileVersion )
+bool CPDF_Creator::SetFileVersion(int32_t fileVersion )
 {
     if (fileVersion < 10 || fileVersion > 17) {
-        return FALSE;
+        return false;
     }
     m_FileVersion = fileVersion;
-    return TRUE;
+    return true;
 }
 void CPDF_Creator::RemoveSecurity()
 {
     ResetStandardSecurity();
-    m_bSecurityChanged = TRUE;
+    m_bSecurityChanged = true;
     m_pEncryptDict = NULL;
     m_pCryptoHandler = NULL;
 }
@@ -2124,7 +2124,7 @@ void CPDF_Creator::ResetStandardSecurity()
         delete m_pCryptoHandler;
         m_pCryptoHandler = NULL;
     }
-    m_bNewCrypto = FALSE;
+    m_bNewCrypto = false;
     if (!m_bStandardSecurity) {
         return;
     }
@@ -2132,5 +2132,5 @@ void CPDF_Creator::ResetStandardSecurity()
         m_pEncryptDict->Release();
         m_pEncryptDict = NULL;
     }
-    m_bStandardSecurity = FALSE;
+    m_bStandardSecurity = false;
 }
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
index 5a5fb94ef3..3621c7957a 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_doc.cpp
@@ -12,7 +12,7 @@ CPDF_Document::CPDF_Document() : CPDF_IndirectObjects(NULL)
 {
     m_pRootDict = NULL;
     m_pInfoDict = NULL;
-    m_bLinearized = FALSE;
+    m_bLinearized = false;
     m_dwFirstPageNo = 0;
     m_dwFirstPageObjNum = 0;
     m_pDocPage = CPDF_ModuleMgr::Get()->GetPageModule()->CreateDocData(this);
@@ -215,7 +215,7 @@ static void _InsertWidthArray(HDC hDC, int start, int end, CPDF_Array* pWidthArr
     }
     FX_Free(widths);
 }
-CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont, FX_BOOL bVert, FX_BOOL bTranslateName)
+CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTW* pLogFont, bool bVert, bool bTranslateName)
 {
     LOGFONTA lfa;
     FXSYS_memcpy(&lfa, pLogFont, (char*)lfa.lfFaceName - (char*)&lfa);
@@ -239,7 +239,7 @@ CFX_ByteString _FPDF_GetPSNameFromTT(HDC hDC)
     }
     return result;
 }
-CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTA* pLogFont, FX_BOOL bVert, FX_BOOL bTranslateName)
+CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTA* pLogFont, bool bVert, bool bTranslateName)
 {
     pLogFont->lfHeight = -1000;
     pLogFont->lfWidth = 0;
@@ -269,7 +269,7 @@ CPDF_Font* CPDF_Document::AddWindowsFont(LOGFONTA* pLogFont, FX_BOOL bVert, FX_B
     if ((pLogFont->lfPitchAndFamily & 0xf8) == FF_SCRIPT) {
         flags |= PDFFONT_SCRIPT;
     }
-    FX_BOOL bCJK = pLogFont->lfCharSet == CHINESEBIG5_CHARSET || pLogFont->lfCharSet == GB2312_CHARSET ||
+    bool bCJK = pLogFont->lfCharSet == CHINESEBIG5_CHARSET || pLogFont->lfCharSet == GB2312_CHARSET ||
                    pLogFont->lfCharSet == HANGEUL_CHARSET || pLogFont->lfCharSet == SHIFTJIS_CHARSET;
     CFX_ByteString basefont;
     if (bTranslateName && bCJK) {
@@ -549,7 +549,7 @@ static void _CFString2CFXByteString(CFStringRef src, CFX_ByteString &dest)
     dest = (FX_CHAR*)pBuffer;
     free(pBuffer);
 }
-FX_BOOL IsHasCharSet(CFArrayRef languages, const CFX_DWordArray &charSets)
+bool IsHasCharSet(CFArrayRef languages, const CFX_DWordArray &charSets)
 {
     int iCount = charSets.GetSize();
     for (int i = 0; i < CFArrayGetCount(languages); ++i) {
@@ -557,11 +557,11 @@ FX_BOOL IsHasCharSet(CFArrayRef languages, const CFX_DWordArray &charSets)
         FX_DWORD CharSet = FX_GetCharsetFromLang(CFStringGetCStringPtr(language, kCFStringEncodingMacRoman), -1);
         for (int j = 0; j < iCount; ++j) {
             if (CharSet == charSets[j]) {
-                return TRUE;
+                return true;
             }
         }
     }
-    return FALSE;
+    return false;
 }
 void FX_GetCharWidth(CTFontRef font, UniChar start, UniChar end, int* width)
 {
@@ -599,7 +599,7 @@ static void _InsertWidthArray(CTFontRef font, int start, int end, CPDF_Array* pW
     }
     FX_Free(widths);
 }
-CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTranslateName)
+CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, bool bVert, bool bTranslateName)
 {
     CTFontRef font = (CTFontRef)pFont;
     CTFontDescriptorRef descriptor = CTFontCopyFontDescriptor(font);
@@ -607,7 +607,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
         return NULL;
     }
     CFX_ByteString basefont;
-    FX_BOOL bCJK = FALSE;
+    bool bCJK = false;
     int flags = 0, italicangle = 0, ascend = 0, descend = 0, capheight = 0, bbox[4];
     FXSYS_memset(bbox, 0, sizeof(int) * 4);
     CFArrayRef languages = (CFArrayRef)CTFontDescriptorCopyAttribute(descriptor, kCTFontLanguagesAttribute);
@@ -621,7 +621,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
     charSets.Add(FXFONT_HANGEUL_CHARSET);
     charSets.Add(FXFONT_SHIFTJIS_CHARSET);
     if (IsHasCharSet(languages, charSets)) {
-        bCJK = TRUE;
+        bCJK = true;
     }
     CFRelease(descriptor);
     CFDictionaryRef traits = (CFDictionaryRef)CTFontCopyTraits(font);
@@ -737,7 +737,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
         CFX_ByteString cmap;
         CFX_ByteString ordering;
         int supplement;
-        FX_BOOL bFound = FALSE;
+        bool bFound = false;
         CPDF_Array* pWidthArray = new CPDF_Array;
         charSets.RemoveAll();
         charSets.Add(FXFONT_CHINESEBIG5_CHARSET);
@@ -747,7 +747,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
             supplement = 4;
             pWidthArray->AddInteger(1);
             _InsertWidthArray(font, 0x20, 0x7e, pWidthArray);
-            bFound = TRUE;
+            bFound = true;
         }
         charSets.RemoveAll();
         charSets.Add(FXFONT_GB2312_CHARSET);
@@ -758,7 +758,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
             _InsertWidthArray(font, 0x20, 0x20, pWidthArray);
             pWidthArray->AddInteger(814);
             _InsertWidthArray(font, 0x21, 0x7e, pWidthArray);
-            bFound = TRUE;
+            bFound = true;
         }
         charSets.RemoveAll();
         charSets.Add(FXFONT_HANGEUL_CHARSET);
@@ -768,7 +768,7 @@ CPDF_Font* CPDF_Document::AddMacFont(CTFontRef pFont, FX_BOOL bVert, FX_BOOL bTr
             supplement = 2;
             pWidthArray->AddInteger(1);
             _InsertWidthArray(font, 0x20, 0x7e, pWidthArray);
-            bFound = TRUE;
+            bFound = true;
         }
         charSets.RemoveAll();
         charSets.Add(FXFONT_SHIFTJIS_CHARSET);
@@ -867,12 +867,12 @@ static void _InsertWidthArray1(CFX_Font* pFont, IFX_FontEncoding* pEncoding, FX_
     }
     FX_Free(widths);
 }
-CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, FX_BOOL bVert)
+CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, bool bVert)
 {
     if (pFont == NULL) {
         return NULL;
     }
-    FX_BOOL bCJK = charset == FXFONT_CHINESEBIG5_CHARSET || charset == FXFONT_GB2312_CHARSET ||
+    bool bCJK = charset == FXFONT_CHINESEBIG5_CHARSET || charset == FXFONT_GB2312_CHARSET ||
                    charset == FXFONT_HANGEUL_CHARSET || charset == FXFONT_SHIFTJIS_CHARSET;
     CFX_ByteString basefont = pFont->GetFamilyName();
     basefont.Replace(" ", "");
@@ -1052,7 +1052,7 @@ CPDF_Font* CPDF_Document::AddFont(CFX_Font* pFont, int charset, FX_BOOL bVert)
     return LoadFont(pBaseDict);
 }
 static int InsertDeletePDFPage(CPDF_Document* pDoc, CPDF_Dictionary* pPages,
-                               int nPagesToGo, CPDF_Dictionary* pPage, FX_BOOL bInsert, CFX_PtrArray& stackList)
+                               int nPagesToGo, CPDF_Dictionary* pPage, bool bInsert, CFX_PtrArray& stackList)
 {
     CPDF_Array* pKidList = pPages->GetArray("Kids");
     if (!pKidList) {
@@ -1122,7 +1122,7 @@ static int InsertNewPage(CPDF_Document* pDoc, int iPage, CPDF_Dictionary* pPageD
     } else {
         CFX_PtrArray stack;
         stack.Add(pPages);
-        if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, TRUE, stack) < 0) {
+        if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, true, stack) < 0) {
             return -1;
         }
     }
@@ -1165,7 +1165,7 @@ void CPDF_Document::DeletePage(int iPage)
     }
     CFX_PtrArray stack;
     stack.Add(pPages);
-    if (InsertDeletePDFPage(this, pPages, iPage, NULL, FALSE, stack) < 0) {
+    if (InsertDeletePDFPage(this, pPages, iPage, NULL, false, stack) < 0) {
         return;
     }
     m_PageList.RemoveAt(iPage);
diff --git a/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp b/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
index dad7326a5b..21ce31e3c3 100644
--- a/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
+++ b/core/src/fpdfapi/fpdf_edit/fpdf_edit_image.cpp
@@ -16,7 +16,7 @@ CPDF_Dictionary* CPDF_Image::InitJPEG(uint8_t* pData, FX_DWORD size)
     int32_t height;
     int32_t num_comps;
     int32_t bits;
-    FX_BOOL color_trans;
+    bool color_trans;
     if (!CPDF_ModuleMgr::Get()->GetJpegModule()->
             LoadInfo(pData, size, width, height, num_comps, bits, color_trans)) {
         return NULL;
@@ -48,7 +48,7 @@ CPDF_Dictionary* CPDF_Image::InitJPEG(uint8_t* pData, FX_DWORD size)
         pDict->SetAt("DecodeParms", pParms);
         pParms->SetAtInteger("ColorTransform", 0);
     }
-    m_bIsMask = FALSE;
+    m_bIsMask = false;
     m_Width = width;
     m_Height = height;
     if (m_pStream == NULL) {
@@ -92,7 +92,7 @@ void CPDF_Image::SetJpegImage(IFX_FileRead *pFile)
 void _DCTEncodeBitmap(CPDF_Dictionary *pBitmapDict, const CFX_DIBitmap* pBitmap, int quality, uint8_t* &buf, FX_STRSIZE &size)
 {
 }
-void _JBIG2EncodeBitmap(CPDF_Dictionary *pBitmapDict, const CFX_DIBitmap *pBitmap, CPDF_Document *pDoc, uint8_t* &buf, FX_STRSIZE &size, FX_BOOL bLossLess)
+void _JBIG2EncodeBitmap(CPDF_Dictionary *pBitmapDict, const CFX_DIBitmap *pBitmap, CPDF_Document *pDoc, uint8_t* &buf, FX_STRSIZE &size, bool bLossLess)
 {
 }
 void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_FileWrite *pFileWrite, IFX_FileRead *pFileRead, const CFX_DIBitmap* pMask, const CPDF_ImageSetParam* pParam)
@@ -105,7 +105,7 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
     uint8_t* src_buf = pBitmap->GetBuffer();
     int32_t src_pitch = pBitmap->GetPitch();
     int32_t bpp = pBitmap->GetBPP();
-    FX_BOOL bUseMatte = pParam && pParam->pMatteColor && (pBitmap->GetFormat() == FXDIB_Argb);
+    bool bUseMatte = pParam && pParam->pMatteColor && (pBitmap->GetFormat() == FXDIB_Argb);
     CPDF_Dictionary* pDict = new CPDF_Dictionary;
     pDict->SetAtName(FX_BSTRC("Type"), FX_BSTRC("XObject"));
     pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image"));
@@ -121,7 +121,7 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
             ArgbDecode(pBitmap->GetPaletteArgb(1), set_a, set_r, set_g, set_b);
         }
         if (set_a == 0 || reset_a == 0) {
-            pDict->SetAt(FX_BSTRC("ImageMask"), new CPDF_Boolean(TRUE));
+            pDict->SetAt(FX_BSTRC("ImageMask"), new CPDF_Boolean(true));
             if (reset_a == 0) {
                 CPDF_Array* pArray = new CPDF_Array;
                 pArray->AddInteger(1);
@@ -142,7 +142,7 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
             pBuf[4] = (FX_CHAR)set_g;
             pBuf[5] = (FX_CHAR)set_b;
             ct.ReleaseBuffer(6);
-            pCS->Add(CPDF_String::Create(ct, TRUE));
+            pCS->Add(CPDF_String::Create(ct, true));
             pDict->SetAt(FX_BSTRC("ColorSpace"), pCS);
         }
         pDict->SetAtInteger(FX_BSTRC("BitsPerComponent"), 1);
@@ -194,10 +194,10 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
         }
     }
     const CFX_DIBitmap* pMaskBitmap = NULL;
-    FX_BOOL bDeleteMask = FALSE;
+    bool bDeleteMask = false;
     if (pBitmap->HasAlpha()) {
         pMaskBitmap = pBitmap->GetAlphaMask();
-        bDeleteMask = TRUE;
+        bDeleteMask = true;
     }
     if (!pMaskBitmap && pMask) {
         FXDIB_Format maskFormat = pMask->GetFormat();
@@ -220,7 +220,7 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
         if (pMaskBitmap->GetBPP() == 8 && (iCompress & PDF_IMAGE_MASK_LOSSY_COMPRESS) != 0) {
             _DCTEncodeBitmap(pMaskDict, pMaskBitmap, pParam ? pParam->nQuality : 75, mask_buf, mask_size);
         } else if (pMaskBitmap->GetFormat() == FXDIB_1bppMask) {
-            _JBIG2EncodeBitmap(pMaskDict, pMaskBitmap, m_pDocument, mask_buf, mask_size, TRUE);
+            _JBIG2EncodeBitmap(pMaskDict, pMaskBitmap, m_pDocument, mask_buf, mask_size, true);
         } else {
             mask_buf = FX_Alloc2D(uint8_t, maskHeight, maskWidth);
             mask_size = maskHeight * maskWidth;  // Safe since checked alloc returned.
@@ -245,15 +245,15 @@ void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, int32_t iCompress, IFX_Fi
             delete pMaskBitmap;
         }
     }
-    FX_BOOL bStream = pFileWrite != NULL && pFileRead != NULL;
+    bool bStream = pFileWrite != NULL && pFileRead != NULL;
     if (opType == 0) {
         if (iCompress & PDF_IMAGE_LOSSLESS_COMPRESS) {
             if (pBitmap->GetBPP() == 1) {
-                _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, TRUE);
+                _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, true);
             }
         } else {
             if (pBitmap->GetBPP() == 1) {
-                _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, FALSE);
+                _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, false);
             } else if (pBitmap->GetBPP() >= 8 && pBitmap->GetPalette() != NULL) {
                 CFX_DIBitmap *pNewBitmap = new CFX_DIBitmap();
                 pNewBitmap->Copy(pBitmap);
diff --git a/core/src/fpdfapi/fpdf_font/font_int.h b/core/src/fpdfapi/fpdf_font/font_int.h
index f57e52758a..e52540853d 100644
--- a/core/src/fpdfapi/fpdf_font/font_int.h
+++ b/core/src/fpdfapi/fpdf_font/font_int.h
@@ -12,15 +12,15 @@ class CPDF_CMapManager
 public:
     CPDF_CMapManager();
     ~CPDF_CMapManager();
-    void*				GetPackage(FX_BOOL bPrompt);
-    CPDF_CMap*				GetPredefinedCMap(const CFX_ByteString& name, FX_BOOL bPrompt);
-    CPDF_CID2UnicodeMap*	GetCID2UnicodeMap(int charset, FX_BOOL bPrompt);
+    void*				GetPackage(bool bPrompt);
+    CPDF_CMap*				GetPredefinedCMap(const CFX_ByteString& name, bool bPrompt);
+    CPDF_CID2UnicodeMap*	GetCID2UnicodeMap(int charset, bool bPrompt);
     void					ReloadAll();
 private:
-    CPDF_CMap*				LoadPredefinedCMap(const CFX_ByteString& name,  FX_BOOL bPrompt);
-    CPDF_CID2UnicodeMap*	LoadCID2UnicodeMap(int charset, FX_BOOL bPrompt);
-    void					DropAll(FX_BOOL bReload);
-    FX_BOOL					m_bPrompted;
+    CPDF_CMap*				LoadPredefinedCMap(const CFX_ByteString& name,  bool bPrompt);
+    CPDF_CID2UnicodeMap*	LoadCID2UnicodeMap(int charset, bool bPrompt);
+    void					DropAll(bool bReload);
+    bool					m_bPrompted;
     CFX_MapByteStringToPtr	m_CMaps;
     CPDF_CID2UnicodeMap*	m_CID2UnicodeMaps[6];
 };
@@ -56,7 +56,7 @@ class CPDF_CMapParser
 public:
     CPDF_CMapParser();
     ~CPDF_CMapParser() {}
-    FX_BOOL	Initialize(CPDF_CMap*);
+    bool	Initialize(CPDF_CMap*);
     void	ParseWord(const CFX_ByteStringC& str);
     CFX_BinaryBuf	m_AddMaps;
 private:
@@ -80,10 +80,10 @@ class CPDF_CMap
 {
 public:
     CPDF_CMap();
-    FX_BOOL					LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* name, FX_BOOL bPromptCJK);
-    FX_BOOL					LoadEmbedded(const uint8_t* pData, FX_DWORD dwSize);
+    bool					LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* name, bool bPromptCJK);
+    bool					LoadEmbedded(const uint8_t* pData, FX_DWORD dwSize);
     void					Release();
-    FX_BOOL					IsLoaded() const
+    bool					IsLoaded() const
     {
         return m_bLoaded;
     }
@@ -91,7 +91,7 @@ public:
     {
         return m_Charset;
     }
-    FX_BOOL					IsVertWriting() const
+    bool					IsVertWriting() const
     {
         return m_bVertical;
     }
@@ -109,14 +109,14 @@ protected:
     friend class			CPDF_CIDFont;
 protected:
     CFX_ByteString			m_PredefinedCMap;
-    FX_BOOL					m_bVertical;
+    bool					m_bVertical;
     int						m_Charset, m_Coding;
     CodingScheme			m_CodingScheme;
     int						m_nCodeRanges;
     uint8_t*				m_pLeadingBytes;
     FX_WORD*				m_pMapping;
     uint8_t*				m_pAddMapping;
-    FX_BOOL					m_bLoaded;
+    bool					m_bLoaded;
     const FXCMAP_CMap*		m_pEmbedMap;
     CPDF_CMap*				m_pUseMap;
 };
@@ -146,9 +146,9 @@ class CPDF_CID2UnicodeMap
 public:
     CPDF_CID2UnicodeMap();
     ~CPDF_CID2UnicodeMap();
-    FX_BOOL		Initialize();
-    FX_BOOL		IsLoaded();
-    void		Load(CPDF_CMapManager* pMgr, int charset, FX_BOOL bPromptCJK);
+    bool		Initialize();
+    bool		IsLoaded();
+    void		Load(CPDF_CMapManager* pMgr, int charset, bool bPromptCJK);
     FX_WCHAR	UnicodeFromCID(FX_WORD CID);
 protected:
     int			m_Charset;
diff --git a/core/src/fpdfapi/fpdf_font/fpdf_font.cpp b/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
index 8037a8c674..afcce6d18c 100644
--- a/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
+++ b/core/src/fpdfapi/fpdf_font/fpdf_font.cpp
@@ -12,16 +12,16 @@
 #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)
@@ -120,7 +120,7 @@ CPDF_Font::CPDF_Font(int fonttype) : m_FontType(fonttype)
     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()
@@ -135,9 +135,9 @@ CPDF_Font::~CPDF_Font()
         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();
@@ -236,33 +236,33 @@ 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;
@@ -316,7 +316,7 @@ void CPDF_Font::CheckFontMetrics()
             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);
@@ -325,7 +325,7 @@ void CPDF_Font::CheckFontMetrics()
                 }
                 if (bFirst) {
                     m_FontBBox = rect;
-                    bFirst = FALSE;
+                    bFirst = false;
                 } else {
                     if (m_FontBBox.top < rect.top) {
                         m_FontBBox.top = rect.top;
@@ -361,7 +361,7 @@ void CPDF_Font::CheckFontMetrics()
 }
 void CPDF_Font::LoadUnicodeMap()
 {
-    m_bToUnicodeLoaded = TRUE;
+    m_bToUnicodeLoaded = true;
     CPDF_Stream* pStream = m_pFontDict->GetStream(FX_BSTRC("ToUnicode"));
     if (pStream == NULL) {
         return;
@@ -466,10 +466,10 @@ CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc, CPDF_Dictionary* pFontDic
     }
     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"));
@@ -623,7 +623,7 @@ 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) {
@@ -719,12 +719,12 @@ void CPDF_ToUnicodeMap::Load(CPDF_Stream* pStream)
         }
     }
     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;
@@ -735,12 +735,12 @@ static FX_BOOL GetPredefinedEncoding(int& basemap, const CFX_ByteString& value)
     } 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")) {
@@ -802,18 +802,18 @@ void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding, int& iBaseEncoding, CFX_
         }
     }
 }
-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)
 {
@@ -828,10 +828,10 @@ 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;
@@ -923,7 +923,7 @@ const FX_CHAR* GetAdobeCharName(int iBaseEncoding, const CFX_ByteString* pCharNa
     }
     return name;
 }
-FX_BOOL CPDF_SimpleFont::LoadCommon()
+bool CPDF_SimpleFont::LoadCommon()
 {
     CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
     if (pFontDesc) {
@@ -931,9 +931,9 @@ FX_BOOL CPDF_SimpleFont::LoadCommon()
     }
     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 ++) {
@@ -970,7 +970,7 @@ FX_BOOL CPDF_SimpleFont::LoadCommon()
     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};
@@ -988,7 +988,7 @@ FX_BOOL CPDF_SimpleFont::LoadCommon()
         }
     }
     CheckFontMetrics();
-    return TRUE;
+    return true;
 }
 void CPDF_SimpleFont::LoadSubstFont()
 {
@@ -1013,7 +1013,7 @@ void CPDF_SimpleFont::LoadSubstFont()
     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;
@@ -1022,7 +1022,7 @@ 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) {
@@ -1046,21 +1046,21 @@ FX_BOOL CPDF_Type1Font::_Load()
     }
     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_
@@ -1112,21 +1112,21 @@ void CPDF_Type1Font::LoadGlyphMap()
         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 ++) {
@@ -1143,7 +1143,7 @@ void CPDF_Type1Font::LoadGlyphMap()
                     }
 #endif
                     if (m_GlyphIndex[charcode]) {
-                        bGotOne = TRUE;
+                        bGotOne = true;
                         break;
                     }
                 }
@@ -1237,9 +1237,9 @@ void CPDF_Type1Font::LoadGlyphMap()
             }
             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);
@@ -1315,9 +1315,9 @@ void CPDF_Type1Font::LoadGlyphMap()
 #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);
@@ -1363,7 +1363,7 @@ CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding)
             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;
 }
@@ -1372,10 +1372,10 @@ 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;
             }
         }
@@ -1413,7 +1413,7 @@ CPDF_Object* CPDF_FontEncoding::Realize()
 CPDF_TrueTypeFont::CPDF_TrueTypeFont() : CPDF_SimpleFont(PDFFONT_TRUETYPE)
 {
 }
-FX_BOOL CPDF_TrueTypeFont::_Load()
+bool CPDF_TrueTypeFont::_Load()
 {
     return LoadCommon();
 }
@@ -1426,14 +1426,14 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
     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) {
@@ -1459,8 +1459,8 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
             }
             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);
@@ -1470,7 +1470,7 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
                 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) {
@@ -1523,13 +1523,13 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
     }
     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;
                 }
             }
@@ -1552,12 +1552,12 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
         }
     }
     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) {
@@ -1565,7 +1565,7 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
         }
     }
     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) {
@@ -1580,7 +1580,7 @@ void CPDF_TrueTypeFont::LoadGlyphMap()
             }
             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) {
@@ -1614,7 +1614,7 @@ CPDF_Type3Font::~CPDF_Type3Font()
         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"));
@@ -1648,7 +1648,7 @@ FX_BOOL CPDF_Type3Font::_Load()
     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]);
@@ -1658,7 +1658,7 @@ FX_BOOL CPDF_Type3Font::_Load()
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Type3Font::CheckType3FontMetrics()
 {
@@ -1736,8 +1736,8 @@ 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()
 {
diff --git a/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp b/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
index f70b9ecfc4..8f95e59dee 100644
--- a/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
+++ b/core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp
@@ -13,18 +13,18 @@
 #include "font_int.h"
 
 extern short TT2PDF(int m, FXFT_Face face);
-extern FX_BOOL FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id);
+extern bool FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id);
 
 CPDF_CMapManager::CPDF_CMapManager()
 {
-    m_bPrompted = FALSE;
+    m_bPrompted = false;
     FXSYS_memset(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
 }
 CPDF_CMapManager::~CPDF_CMapManager()
 {
-    DropAll(FALSE);
+    DropAll(false);
 }
-CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name, FX_BOOL bPromptCJK)
+CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name, bool bPromptCJK)
 {
     CPDF_CMap* pCMap;
     if (m_CMaps.Lookup(name, (void*&)pCMap)) {
@@ -37,7 +37,7 @@ CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name, FX_BO
     m_CMaps.SetAt(name, pCMap);
     return pCMap;
 }
-CPDF_CMap* CPDF_CMapManager::LoadPredefinedCMap(const CFX_ByteString& name, FX_BOOL bPromptCJK)
+CPDF_CMap* CPDF_CMapManager::LoadPredefinedCMap(const CFX_ByteString& name, bool bPromptCJK)
 {
     CPDF_CMap* pCMap = new CPDF_CMap;
     const FX_CHAR* pname = name;
@@ -59,9 +59,9 @@ int _CharsetFromOrdering(const CFX_ByteString& Ordering)
 }
 void CPDF_CMapManager::ReloadAll()
 {
-    DropAll(TRUE);
+    DropAll(true);
 }
-void CPDF_CMapManager::DropAll(FX_BOOL bReload)
+void CPDF_CMapManager::DropAll(bool bReload)
 {
     FX_POSITION pos = m_CMaps.GetStartPosition();
     while (pos) {
@@ -72,7 +72,7 @@ void CPDF_CMapManager::DropAll(FX_BOOL bReload)
             continue;
         }
         if (bReload) {
-            pCMap->LoadPredefined(this, name, FALSE);
+            pCMap->LoadPredefined(this, name, false);
         } else {
             delete pCMap;
         }
@@ -83,20 +83,20 @@ void CPDF_CMapManager::DropAll(FX_BOOL bReload)
             continue;
         }
         if (bReload) {
-            pMap->Load(this, i, FALSE);
+            pMap->Load(this, i, false);
         } else {
             delete pMap;
         }
     }
 }
-CPDF_CID2UnicodeMap* CPDF_CMapManager::GetCID2UnicodeMap(int charset, FX_BOOL bPromptCJK)
+CPDF_CID2UnicodeMap* CPDF_CMapManager::GetCID2UnicodeMap(int charset, bool bPromptCJK)
 {
     if (m_CID2UnicodeMaps[charset] == NULL) {
         m_CID2UnicodeMaps[charset] = LoadCID2UnicodeMap(charset, bPromptCJK);
     }
     return m_CID2UnicodeMaps[charset];
 }
-CPDF_CID2UnicodeMap* CPDF_CMapManager::LoadCID2UnicodeMap(int charset, FX_BOOL bPromptCJK)
+CPDF_CID2UnicodeMap* CPDF_CMapManager::LoadCID2UnicodeMap(int charset, bool bPromptCJK)
 {
     CPDF_CID2UnicodeMap* pMap = new CPDF_CID2UnicodeMap();
     if (!pMap->Initialize()) {
@@ -112,13 +112,13 @@ CPDF_CMapParser::CPDF_CMapParser()
     m_Status = 0;
     m_CodeSeq = 0;
 }
-FX_BOOL	CPDF_CMapParser::Initialize(CPDF_CMap* pCMap)
+bool	CPDF_CMapParser::Initialize(CPDF_CMap* pCMap)
 {
     m_pCMap = pCMap;
     m_Status = 0;
     m_CodeSeq = 0;
     m_AddMaps.EstimateSize(0, 10240);
-    return TRUE;
+    return true;
 }
 static FX_DWORD CMap_GetCode(const CFX_ByteStringC& word)
 {
@@ -147,10 +147,10 @@ static FX_DWORD CMap_GetCode(const CFX_ByteStringC& word)
     }
     return num;
 }
-static FX_BOOL _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC& first, const CFX_ByteStringC& second)
+static bool _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC& first, const CFX_ByteStringC& second)
 {
     if (first.GetLength() == 0 || first.GetAt(0) != '<') {
-        return FALSE;
+        return false;
     }
     int i;
     for (i = 1; i < first.GetLength(); i ++)
@@ -159,7 +159,7 @@ static FX_BOOL _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC&
         }
     range.m_CharSize = (i - 1) / 2;
     if (range.m_CharSize > 4) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < range.m_CharSize; i ++) {
         uint8_t digit1 = first.GetAt(i * 2 + 1);
@@ -176,7 +176,7 @@ static FX_BOOL _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC&
         byte = byte * 16 + ((digit2 >= '0' && digit2 <= '9') ? (digit2 - '0') : ((digit2 & 0xdf) - 'A' + 10));
         range.m_Upper[i] = byte;
     }
-    return TRUE;
+    return true;
 }
 static CFX_ByteString CMap_GetString(const CFX_ByteStringC& word)
 {
@@ -282,7 +282,7 @@ CPDF_CMap::CPDF_CMap()
     m_Coding = CIDCODING_UNKNOWN;
     m_CodingScheme = TwoBytes;
     m_bVertical = 0;
-    m_bLoaded = FALSE;
+    m_bLoaded = false;
     m_pMapping = NULL;
     m_pLeadingBytes = NULL;
     m_pAddMapping = NULL;
@@ -346,14 +346,14 @@ const CPDF_PredefinedCMap g_PredefinedCMaps[] = {
 };
 extern void FPDFAPI_FindEmbeddedCMap(const char* name, int charset, int coding, const FXCMAP_CMap*& pMap);
 extern FX_WORD FPDFAPI_CIDFromCharCode(const FXCMAP_CMap* pMap, FX_DWORD charcode);
-FX_BOOL CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName, FX_BOOL bPromptCJK)
+bool CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName, bool bPromptCJK)
 {
     m_PredefinedCMap = pName;
     if (m_PredefinedCMap == FX_BSTRC("Identity-H") || m_PredefinedCMap == FX_BSTRC("Identity-V")) {
         m_Coding = CIDCODING_CID;
         m_bVertical = pName[9] == 'V';
-        m_bLoaded = TRUE;
-        return TRUE;
+        m_bLoaded = true;
+        return true;
     }
     CFX_ByteString cmapid = m_PredefinedCMap;
     m_bVertical = cmapid.Right(1) == FX_BSTRC("V");
@@ -363,7 +363,7 @@ FX_BOOL CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName,
     int index = 0;
     while (1) {
         if (g_PredefinedCMaps[index].m_pName == NULL) {
-            return FALSE;
+            return false;
         }
         if (cmapid == CFX_ByteStringC(g_PredefinedCMaps[index].m_pName)) {
             break;
@@ -384,10 +384,10 @@ FX_BOOL CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName,
     }
     FPDFAPI_FindEmbeddedCMap(pName, m_Charset, m_Coding, m_pEmbedMap);
     if (m_pEmbedMap) {
-        m_bLoaded = TRUE;
-        return TRUE;
+        m_bLoaded = true;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 extern "C" {
     static int compare_dword(const void* data1, const void* data2)
@@ -395,7 +395,7 @@ extern "C" {
         return (*(FX_DWORD*)data1) - (*(FX_DWORD*)data2);
     }
 };
-FX_BOOL CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size)
+bool CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size)
 {
     m_pMapping = FX_Alloc(FX_WORD, 65536);
     CPDF_CMapParser parser;
@@ -414,7 +414,7 @@ FX_BOOL CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size)
         FXSYS_memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), parser.m_AddMaps.GetSize());
         FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8, compare_dword);
     }
-    return TRUE;
+    return true;
 }
 extern "C" {
     static int compareCID(const void* key, const void* element)
@@ -668,11 +668,11 @@ CPDF_CID2UnicodeMap::CPDF_CID2UnicodeMap()
 CPDF_CID2UnicodeMap::~CPDF_CID2UnicodeMap()
 {
 }
-FX_BOOL CPDF_CID2UnicodeMap::Initialize()
+bool CPDF_CID2UnicodeMap::Initialize()
 {
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CID2UnicodeMap::IsLoaded()
+bool CPDF_CID2UnicodeMap::IsLoaded()
 {
     return m_EmbeddedCount != 0;
 }
@@ -687,7 +687,7 @@ FX_WCHAR CPDF_CID2UnicodeMap::UnicodeFromCID(FX_WORD CID)
     return 0;
 }
 void FPDFAPI_LoadCID2UnicodeMap(int charset, const FX_WORD*& pMap, FX_DWORD& count);
-void CPDF_CID2UnicodeMap::Load(CPDF_CMapManager* pMgr, int charset, FX_BOOL bPromptCJK)
+void CPDF_CID2UnicodeMap::Load(CPDF_CMapManager* pMgr, int charset, bool bPromptCJK)
 {
     m_Charset = charset;
     FPDFAPI_LoadCID2UnicodeMap(charset, m_pEmbeddedMap, m_EmbeddedCount);
@@ -700,8 +700,8 @@ CPDF_CIDFont::CPDF_CIDFont() : CPDF_Font(PDFFONT_CIDFONT)
     m_pCID2UnicodeMap = NULL;
     m_pAnsiWidths = NULL;
     m_pCIDToGIDMap = NULL;
-    m_bCIDIsGID = FALSE;
-    m_bAdobeCourierStd = FALSE;
+    m_bCIDIsGID = false;
+    m_bAdobeCourierStd = false;
     m_pTTGSUBTable = NULL;
     FXSYS_memset(m_CharBBox, 0xff, 256 * sizeof(FX_SMALL_RECT));
 }
@@ -721,9 +721,9 @@ FX_WORD CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const
     }
     return m_pCMap->CIDFromCharCode(charcode);
 }
-FX_BOOL CPDF_CIDFont::IsVertWriting() const
+bool CPDF_CIDFont::IsVertWriting() const
 {
-    return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
+    return m_pCMap ? m_pCMap->IsVertWriting() : false;
 }
 extern FX_DWORD FPDFAPI_CharCodeFromCID(const FXCMAP_CMap* pMap, FX_WORD cid);
 static FX_DWORD _EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap, int charset, FX_WCHAR unicode)
@@ -873,27 +873,27 @@ static void FT_UseCIDCharmap(FXFT_Face face, int coding)
         FXFT_Set_Charmap(face, *FXFT_Get_Face_Charmaps(face));
     }
 }
-FX_BOOL CPDF_CIDFont::_Load()
+bool CPDF_CIDFont::_Load()
 {
     if (m_pFontDict->GetString(FX_BSTRC("Subtype")) == FX_BSTRC("TrueType")) {
         return LoadGB2312();
     }
     CPDF_Array* pFonts = m_pFontDict->GetArray(FX_BSTRC("DescendantFonts"));
     if (pFonts == NULL) {
-        return FALSE;
+        return false;
     }
     if (pFonts->GetCount() != 1) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pCIDFontDict = pFonts->GetDict(0);
     if (pCIDFontDict == NULL) {
-        return FALSE;
+        return false;
     }
     m_BaseFont = pCIDFontDict->GetString(FX_BSTRC("BaseFont"));
     if ((m_BaseFont.Compare("CourierStd") == 0 || m_BaseFont.Compare("CourierStd-Bold") == 0
             || m_BaseFont.Compare("CourierStd-BoldOblique") == 0 || m_BaseFont.Compare("CourierStd-Oblique") == 0)
             && !IsEmbedded()) {
-        m_bAdobeCourierStd = TRUE;
+        m_bAdobeCourierStd = true;
     }
     CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDict(FX_BSTRC("FontDescriptor"));
     if (pFontDesc) {
@@ -901,12 +901,12 @@ FX_BOOL CPDF_CIDFont::_Load()
     }
     CPDF_Object* pEncoding = m_pFontDict->GetElementValue(FX_BSTRC("Encoding"));
     if (pEncoding == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString subtype = pCIDFontDict->GetString(FX_BSTRC("Subtype"));
-    m_bType1 = FALSE;
+    m_bType1 = false;
     if (subtype == FX_BSTRC("CIDFontType0")) {
-        m_bType1 = TRUE;
+        m_bType1 = true;
     }
     if (pEncoding->GetType() == PDFOBJ_NAME) {
         CFX_ByteString cmap = pEncoding->GetString();
@@ -916,13 +916,13 @@ FX_BOOL CPDF_CIDFont::_Load()
         m_pAllocatedCMap = m_pCMap = new CPDF_CMap;
         CPDF_Stream* pStream = (CPDF_Stream*)pEncoding;
         CPDF_StreamAcc acc;
-        acc.LoadAllData(pStream, FALSE);
+        acc.LoadAllData(pStream, false);
         m_pCMap->LoadEmbedded(acc.GetData(), acc.GetSize());
     } else {
-        return FALSE;
+        return false;
     }
     if (m_pCMap == NULL) {
-        return FALSE;
+        return false;
     }
     m_Charset = m_pCMap->m_Charset;
     if (m_Charset == CIDSET_UNKNOWN) {
@@ -955,14 +955,14 @@ FX_BOOL CPDF_CIDFont::_Load()
             if (pmap) {
                 if (pmap->GetType() == PDFOBJ_STREAM) {
                     m_pCIDToGIDMap = new CPDF_StreamAcc;
-                    m_pCIDToGIDMap->LoadAllData((CPDF_Stream*)pmap, FALSE);
+                    m_pCIDToGIDMap->LoadAllData((CPDF_Stream*)pmap, false);
                 } else if (pmap->GetString() == FX_BSTRC("Identity")) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                     if (m_pFontFile) {
-                        m_bCIDIsGID = TRUE;
+                        m_bCIDIsGID = true;
                     }
 #else
-                    m_bCIDIsGID = TRUE;
+                    m_bCIDIsGID = true;
 #endif
                 }
             }
@@ -983,7 +983,7 @@ FX_BOOL CPDF_CIDFont::_Load()
             m_DefaultW1 = -1000;
         }
     }
-    return TRUE;
+    return true;
 }
 FX_FLOAT _CIDTransformToFloat(uint8_t ch)
 {
@@ -1001,7 +1001,7 @@ void CPDF_CIDFont::GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level)
         rect.top = m_CharBBox[charcode].Top;
         return;
     }
-    FX_BOOL bVert = FALSE;
+    bool bVert = false;
     int glyph_index = GlyphFromCharCode(charcode, &bVert);
     if (m_Font.m_Face == NULL) {
         rect = FX_RECT(0, 0, 0, 0);
@@ -1120,10 +1120,10 @@ void CPDF_CIDFont::GetVertOrigin(FX_WORD CID, short& vx, short &vy) const
     vx = (short)dwWidth / 2;
     vy = (short)m_DefaultVY;
 }
-int	CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL *pVertGlyph)
+int	CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, bool *pVertGlyph)
 {
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     int index = FXFT_Get_Char_Index(m_Font.m_Face, unicode );
     if (unicode == 0x2502) {
@@ -1136,7 +1136,7 @@ int	CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL *pVertGlyph)
             if (vindex) {
                 index = vindex;
                 if (pVertGlyph) {
-                    *pVertGlyph = TRUE;
+                    *pVertGlyph = true;
                 }
             }
             return index;
@@ -1157,21 +1157,21 @@ int	CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL *pVertGlyph)
             if (vindex) {
                 index = vindex;
                 if (pVertGlyph) {
-                    *pVertGlyph = TRUE;
+                    *pVertGlyph = true;
                 }
             }
         }
         return index;
     }
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     return index;
 }
-int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph)
+int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, bool *pVertGlyph)
 {
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     if (m_pFontFile == NULL && m_pCIDToGIDMap == NULL) {
         FX_WORD cid = CIDFromCharCode(charcode);
@@ -1206,8 +1206,8 @@ int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph)
             }
             charcode += 31;
             int index = 0, iBaseEncoding;
-            FX_BOOL bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
-            FX_BOOL bMacRoman = FALSE;
+            bool bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
+            bool bMacRoman = false;
             if (!bMSUnicode) {
                 bMacRoman = FT_UseTTCharmap(m_Font.m_Face, 1, 0);
             }
@@ -1327,16 +1327,16 @@ int CPDF_CIDFont::AppendChar(FX_CHAR* str, FX_DWORD charcode) const
 {
     return m_pCMap->AppendChar(str, charcode);
 }
-FX_BOOL CPDF_CIDFont::IsUnicodeCompatible() const
+bool CPDF_CIDFont::IsUnicodeCompatible() const
 {
     if (!m_pCMap->IsLoaded() || m_pCID2UnicodeMap == NULL || !m_pCID2UnicodeMap->IsLoaded()) {
         return m_pCMap->m_Coding != CIDCODING_UNKNOWN;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const
+bool CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const
 {
-    return TRUE;
+    return true;
 }
 void CPDF_CIDFont::LoadSubstFont()
 {
@@ -1390,7 +1390,7 @@ void CPDF_CIDFont::LoadMetricsArray(CPDF_Array* pArray, CFX_DWordArray& result,
         }
     }
 }
-FX_BOOL CPDF_CIDFont::LoadGB2312()
+bool CPDF_CIDFont::LoadGB2312()
 {
     m_BaseFont = m_pFontDict->GetString(FX_BSTRC("BaseFont"));
     CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
@@ -1398,10 +1398,10 @@ FX_BOOL CPDF_CIDFont::LoadGB2312()
         LoadFontDescriptor(pFontDesc);
     }
     m_Charset = CIDSET_GB1;
-    m_bType1 = FALSE;
+    m_bType1 = false;
     m_pCMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetPredefinedCMap(
-                  FX_BSTRC("GBK-EUC-H"), FALSE);
-    m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(m_Charset, FALSE);
+                  FX_BSTRC("GBK-EUC-H"), false);
+    m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(m_Charset, false);
     if (!IsEmbedded()) {
         LoadSubstFont();
     }
@@ -1411,7 +1411,7 @@ FX_BOOL CPDF_CIDFont::LoadGB2312()
     for (int i = 32; i < 127; i ++) {
         m_pAnsiWidths[i] = 500;
     }
-    return TRUE;
+    return true;
 }
 const struct _CIDTransform {
     FX_WORD		CID;
diff --git a/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp b/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
index a65359c1d4..980e16c43e 100644
--- a/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
+++ b/core/src/fpdfapi/fpdf_font/ttgsubtable.cpp
@@ -48,15 +48,15 @@ void CFX_GlyphMap::SetAt(int key, int value)
     }
     m_Buffer.InsertBlock(low * sizeof(_IntPair), &pair, sizeof(_IntPair));
 }
-FX_BOOL CFX_GlyphMap::Lookup(int key, int &value)
+bool CFX_GlyphMap::Lookup(int key, int &value)
 {
     void* pResult = FXSYS_bsearch(&key, m_Buffer.GetBuffer(), m_Buffer.GetSize() / sizeof(_IntPair),
                                       sizeof(_IntPair), _CompareInt);
     if (pResult == NULL) {
-        return FALSE;
+        return false;
     }
     value = ((FX_DWORD*)pResult)[1];
-    return TRUE;
+    return true;
 }
 bool CFX_CTTGSUBTable::LoadGSUBTable(FT_Bytes gsub)
 {
@@ -108,7 +108,7 @@ bool CFX_CTTGSUBTable::GetVerticalGlyph(TT_uint32_t glyphnum, TT_uint32_t *vglyp
                 }
             }
         }
-        m_bFeautureMapLoad = TRUE;
+        m_bFeautureMapLoad = true;
     }
     FX_POSITION pos = m_featureMap.GetStartPosition();
     while (pos) {
@@ -420,7 +420,7 @@ void CFX_CTTGSUBTable::ParseSingleSubstFormat2(FT_Bytes raw, TSingleSubstFormat2
         rec->Substitute[i] = GetUInt16(sp);
     }
 }
-FX_BOOL CFX_GSUBTable::GetVerticalGlyph(FX_DWORD glyphnum, FX_DWORD* vglyphnum)
+bool CFX_GSUBTable::GetVerticalGlyph(FX_DWORD glyphnum, FX_DWORD* vglyphnum)
 {
     return m_GsubImp.GetVerticalGlyph(glyphnum, vglyphnum);
 }
diff --git a/core/src/fpdfapi/fpdf_font/ttgsubtable.h b/core/src/fpdfapi/fpdf_font/ttgsubtable.h
index 1b18f82d6e..133667b4d8 100644
--- a/core/src/fpdfapi/fpdf_font/ttgsubtable.h
+++ b/core/src/fpdfapi/fpdf_font/ttgsubtable.h
@@ -17,15 +17,15 @@ public:
     CFX_GlyphMap();
     ~CFX_GlyphMap();
     void	SetAt(int key, int value);
-    FX_BOOL	Lookup(int key, int &value);
+    bool	Lookup(int key, int &value);
 protected:
     CFX_BinaryBuf	m_Buffer;
 };
 class CFX_CTTGSUBTable
 {
 public:
-    CFX_CTTGSUBTable(void): m_bFeautureMapLoad(FALSE), loaded(false) {};
-    CFX_CTTGSUBTable(FT_Bytes gsub): m_bFeautureMapLoad(FALSE), loaded(false)
+    CFX_CTTGSUBTable(void): m_bFeautureMapLoad(false), loaded(false) {};
+    CFX_CTTGSUBTable(FT_Bytes gsub): m_bFeautureMapLoad(false), loaded(false)
     {
         LoadGSUBTable(gsub);
     }
@@ -395,7 +395,7 @@ private:
         return ret;
     }
     CFX_CMapDWordToDWord m_featureMap;
-    FX_BOOL	m_bFeautureMapLoad;
+    bool	m_bFeautureMapLoad;
     bool loaded;
     struct tt_gsub_header header;
     struct TScriptList ScriptList;
@@ -406,7 +406,7 @@ class CFX_GSUBTable final : public IFX_GSUBTable
 {
 public:
     ~CFX_GSUBTable() override {}
-    virtual FX_BOOL GetVerticalGlyph(FX_DWORD glyphnum, FX_DWORD* vglyphnum) override;
+    virtual bool GetVerticalGlyph(FX_DWORD glyphnum, FX_DWORD* vglyphnum) override;
 
     CFX_CTTGSUBTable m_GsubImp;
 };
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
index c0cdb228f4..6b15bd1c49 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page.cpp
@@ -44,7 +44,7 @@ void CPDF_PageObject::Copy(const CPDF_PageObject* pSrc)
     m_Top = pSrc->m_Top;
     m_Bottom = pSrc->m_Bottom;
 }
-void CPDF_PageObject::AppendClipPath(CPDF_Path path, int type, FX_BOOL bAutoMerge)
+void CPDF_PageObject::AppendClipPath(CPDF_Path path, int type, bool bAutoMerge)
 {
     m_ClipPath.AppendPath(path, type, bAutoMerge);
 }
@@ -353,7 +353,7 @@ FX_FLOAT CPDF_TextObject::GetCharWidth(FX_DWORD charcode) const
 {
     FX_FLOAT fontsize = m_TextState.GetFontSize() / 1000;
     CPDF_Font* pFont = m_TextState.GetFont();
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
@@ -373,7 +373,7 @@ FX_FLOAT CPDF_TextObject::GetSpaceCharWidth() const
         return GetCharWidth(charCode);
     }
     FX_FLOAT fontSize = m_TextState.GetFontSize() / 4000.0f;
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
@@ -388,7 +388,7 @@ FX_FLOAT CPDF_TextObject::GetSpaceCharWidth() const
 void CPDF_TextObject::GetCharRect(int index, CFX_FloatRect& rect) const
 {
     CPDF_Font* pFont = m_TextState.GetFont();
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
@@ -441,7 +441,7 @@ void CPDF_TextObject::CalcPositionData(FX_FLOAT* pTextAdvanceX,
     FX_FLOAT min_y = 10000 * 1.0f;
     FX_FLOAT max_y = -10000 * 1.0f;
     CPDF_Font* pFont = m_TextState.GetFont();
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
@@ -570,7 +570,7 @@ void CPDF_TextObject::CalcPositionData(FX_FLOAT* pTextAdvanceX,
 void CPDF_TextObject::CalcCharPos(FX_FLOAT* pPosArray) const
 {
     CPDF_Font* pFont = m_TextState.GetFont();
-    FX_BOOL bVertWriting = FALSE;
+    bool bVertWriting = false;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
     if (pCIDFont) {
         bVertWriting = pCIDFont->IsVertWriting();
@@ -720,9 +720,9 @@ void CPDF_FormObject::CalcBoundingBox()
     m_Right = form_rect.right;
     m_Top = form_rect.top;
 }
-CPDF_PageObjects::CPDF_PageObjects(FX_BOOL bReleaseMembers) : m_ObjectList(128)
+CPDF_PageObjects::CPDF_PageObjects(bool bReleaseMembers) : m_ObjectList(128)
 {
-    m_bBackgroundAlphaNeeded = FALSE;
+    m_bBackgroundAlphaNeeded = false;
     m_bReleaseMembers = bReleaseMembers;
     m_ParseState = PDF_CONTENT_NOT_PARSED;
     m_pParser = NULL;
@@ -858,7 +858,7 @@ CPDF_Page::CPDF_Page()
 {
     m_pPageRender = NULL;
 }
-void CPDF_Page::Load(CPDF_Document* pDocument, CPDF_Dictionary* pPageDict, FX_BOOL bPageCache)
+void CPDF_Page::Load(CPDF_Document* pDocument, CPDF_Dictionary* pPageDict, bool bPageCache)
 {
     m_pDocument = (CPDF_Document*)pDocument;
     m_pFormDict = pPageDict;
@@ -925,7 +925,7 @@ void CPDF_Page::Load(CPDF_Document* pDocument, CPDF_Dictionary* pPageDict, FX_BO
     m_Transparency = PDFTRANS_ISOLATED;
     LoadTransInfo();
 }
-void CPDF_Page::StartParse(CPDF_ParseOptions* pOptions, FX_BOOL bReParse)
+void CPDF_Page::StartParse(CPDF_ParseOptions* pOptions, bool bReParse)
 {
     if (bReParse) {
         ClearCacheObjects();
@@ -937,7 +937,7 @@ void CPDF_Page::StartParse(CPDF_ParseOptions* pOptions, FX_BOOL bReParse)
     m_pParser->Start(this, pOptions);
     m_ParseState = PDF_CONTENT_PARSING;
 }
-void CPDF_Page::ParseContent(CPDF_ParseOptions* pOptions, FX_BOOL bReParse)
+void CPDF_Page::ParseContent(CPDF_ParseOptions* pOptions, bool bReParse)
 {
     StartParse(pOptions, bReParse);
     ContinueParse(NULL);
@@ -1070,8 +1070,8 @@ void CPDF_Page::GetDisplayMatrix(CFX_AffineMatrix& matrix, int xPos, int yPos,
 }
 CPDF_ParseOptions::CPDF_ParseOptions()
 {
-    m_bTextOnly = FALSE;
-    m_bMarkedContent = TRUE;
-    m_bSeparateForm = TRUE;
-    m_bDecodeInlineImage = FALSE;
+    m_bTextOnly = false;
+    m_bMarkedContent = true;
+    m_bSeparateForm = true;
+    m_bDecodeInlineImage = false;
 }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
index 198054ef7e..b1c8837326 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_colors.cpp
@@ -40,7 +40,7 @@ CPDF_DeviceCS::CPDF_DeviceCS(CPDF_Document* pDoc, int family)
         : CPDF_ColorSpace(pDoc, family, ComponentsForFamily(family)) {
 }
 
-FX_BOOL CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         R = pBuf[0];
@@ -81,56 +81,56 @@ FX_BOOL CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT
     } else {
         ASSERT(m_Family == PDFCS_PATTERN);
         R = G = B = 0;
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_DeviceCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (m_Family != PDFCS_DEVICECMYK) {
-        return FALSE;
+        return false;
     }
     c = pBuf[0];
     m = pBuf[1];
     y = pBuf[2];
     k = pBuf[3];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_DeviceCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         pBuf[0] = R;
         pBuf[1] = G;
         pBuf[2] = B;
-        return TRUE;
+        return true;
     }
     if (m_Family == PDFCS_DEVICEGRAY) {
         if (R == G && R == B) {
             *pBuf = R;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (m_Family == PDFCS_DEVICECMYK) {
         sRGB_to_AdobeCMYK(R, G, B, pBuf[0], pBuf[1], pBuf[2], pBuf[3]);
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DeviceCS::v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
+bool CPDF_DeviceCS::v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 {
     if (m_Family == PDFCS_DEVICERGB) {
         AdobeCMYK_to_sRGB(c, m, y, k, pBuf[0], pBuf[1], pBuf[2]);
-        return TRUE;
+        return true;
     }
     if (m_Family == PDFCS_DEVICECMYK) {
         pBuf[0] = c;
         pBuf[1] = m;
         pBuf[2] = y;
         pBuf[3] = k;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 static void ReverseRGB(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels)
 {
@@ -149,7 +149,7 @@ static void ReverseRGB(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels)
             pSrcBuf += 3;
         }
 }
-void CPDF_DeviceCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_DeviceCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (bTransMask && m_Family == PDFCS_DEVICECMYK) {
         for (int i = 0; i < pixels; i ++) {
@@ -274,11 +274,11 @@ public:
     explicit CPDF_CalGray(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_CALGRAY, 1) {
     }
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
 private:
     FX_FLOAT m_WhitePoint[3];
@@ -286,7 +286,7 @@ private:
     FX_FLOAT m_Gamma;
 };
 
-FX_BOOL CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
@@ -302,22 +302,22 @@ FX_BOOL CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
     if (m_Gamma == 0) {
         m_Gamma = 1.0f;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalGray::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_CalGray::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     R = G = B = *pBuf;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalGray::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_CalGray::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     if (R == G && R == B) {
         *pBuf = R;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-void CPDF_CalGray::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_CalGray::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     for (int i = 0; i < pixels; i ++) {
         *pDestBuf ++ = pSrcBuf[i];
@@ -331,24 +331,24 @@ public:
     explicit CPDF_CalRGB(CPDF_Document* pDoc)
         : CPDF_ColorSpace(pDoc, PDFCS_CALRGB, 3) {
     }
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
     FX_FLOAT m_WhitePoint[3];
     FX_FLOAT m_BlackPoint[3];
     FX_FLOAT m_Gamma[3];
     FX_FLOAT m_Matrix[9];
-    FX_BOOL m_bGamma;
-    FX_BOOL m_bMatrix;
+    bool m_bGamma;
+    bool m_bMatrix;
 };
-FX_BOOL CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     if (!pDict)
-        return FALSE;
+        return false;
 
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
     int i;
@@ -361,25 +361,25 @@ FX_BOOL CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
     }
     pParam = pDict->GetArray(FX_BSTRC("Gamma"));
     if (pParam) {
-        m_bGamma = TRUE;
+        m_bGamma = true;
         for (i = 0; i < 3; i ++) {
             m_Gamma[i] = pParam->GetNumber(i);
         }
     } else {
-        m_bGamma = FALSE;
+        m_bGamma = false;
     }
     pParam = pDict->GetArray(FX_BSTRC("Matrix"));
     if (pParam) {
-        m_bMatrix = TRUE;
+        m_bMatrix = true;
         for (i = 0; i < 9; i ++) {
             m_Matrix[i] = pParam->GetNumber(i);
         }
     } else {
-        m_bMatrix = FALSE;
+        m_bMatrix = false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     FX_FLOAT A_ = pBuf[0];
     FX_FLOAT B_ = pBuf[1];
@@ -400,16 +400,16 @@ FX_BOOL CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT&
         Z = C_;
     }
     XYZ_to_sRGB_WhitePoint(X, Y, Z, R, G, B, m_WhitePoint[0], m_WhitePoint[1], m_WhitePoint[2]);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CalRGB::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_CalRGB::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
     pBuf[0] = R;
     pBuf[1] = G;
     pBuf[2] = B;
-    return TRUE;
+    return true;
 }
-void CPDF_CalRGB::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_CalRGB::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (bTransMask) {
         FX_FLOAT Cal[3];
@@ -435,21 +435,21 @@ public:
         : CPDF_ColorSpace(pDoc, PDFCS_LAB, 3) {
     }
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL	GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool	GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const;
+                            int image_height, bool bTransMask = false) const;
 
     FX_FLOAT m_WhitePoint[3];
     FX_FLOAT m_BlackPoint[3];
     FX_FLOAT m_Ranges[4];
 };
-FX_BOOL CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Dictionary* pDict = pArray->GetDict(1);
     if (!pDict) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pParam = pDict->GetArray(FX_BSTRC("WhitePoint"));
     int i;
@@ -465,7 +465,7 @@ FX_BOOL CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
     for (i = 0; i < 4; i ++) {
         m_Ranges[i] = pParam ? pParam->GetNumber(i) : def_ranges[i];
     }
-    return TRUE;
+    return true;
 }
 void CPDF_LabCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
 {
@@ -484,7 +484,7 @@ void CPDF_LabCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min,
         }
     }
 }
-FX_BOOL CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     FX_FLOAT Lstar = pBuf[0];
     FX_FLOAT astar = pBuf[1];
@@ -509,13 +509,13 @@ FX_BOOL CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B
         Z = 1.0889f * N * N * N;
     }
     XYZ_to_sRGB(X, Y, Z, R, G, B);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_LabCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_LabCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
-    return FALSE;
+    return false;
 }
-void CPDF_LabCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_LabCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     for (int i = 0; i < pixels; i ++) {
         FX_FLOAT lab[3];
@@ -532,12 +532,12 @@ void CPDF_LabCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, i
     }
 }
 CPDF_IccProfile::CPDF_IccProfile(const uint8_t* pData, FX_DWORD dwSize):
-    m_bsRGB(FALSE),
+    m_bsRGB(false),
     m_pTransform(NULL),
     m_nSrcComponents(0)
 {
     if (dwSize == 3144 && FXSYS_memcmp(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0) {
-        m_bsRGB = TRUE;
+        m_bsRGB = true;
         m_nSrcComponents = 3;
     }
     else if (CPDF_ModuleMgr::Get()->GetIccModule()) {
@@ -559,23 +559,23 @@ public:
           m_pProfile(nullptr),
           m_pCache(nullptr),
           m_pRanges(nullptr),
-          m_bOwn(FALSE) {
+          m_bOwn(false) {
     }
     ~CPDF_ICCBasedCS() override;
 
-    FX_BOOL	v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    FX_BOOL	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
-    FX_BOOL	v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool	v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool	SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const override;
+    bool	v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const override;
+    void EnableStdConversion(bool bEnabled) override;
     void TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width,
-                            int image_height, FX_BOOL bTransMask = FALSE) const override;
+                            int image_height, bool bTransMask = false) const override;
 
     CPDF_ColorSpace* m_pAlterCS;
     CPDF_IccProfile* m_pProfile;
     uint8_t* m_pCache;
     FX_FLOAT* m_pRanges;
-    FX_BOOL	m_bOwn;
+    bool	m_bOwn;
 };
 
 CPDF_ICCBasedCS::~CPDF_ICCBasedCS()
@@ -594,15 +594,15 @@ CPDF_ICCBasedCS::~CPDF_ICCBasedCS()
     }
 }
 
-FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Stream* pStream = pArray->GetStream(1);
     if (pStream == NULL) {
-        return FALSE;
+        return false;
     }
     m_pProfile = pDoc->LoadIccProfile(pStream);
     if (!m_pProfile) {
-        return FALSE;
+        return false;
     }
     m_nComponents = m_pProfile->GetComponents(); //Try using the nComponents from ICC profile
     CPDF_Dictionary* pDict = pStream->GetDict();
@@ -615,13 +615,13 @@ FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
                     if (pAlterCS->CountComponents() > 0) { // Use Alternative colorspace
                         m_nComponents = pAlterCS->CountComponents();
                         m_pAlterCS = pAlterCS;
-                        m_bOwn = TRUE;
+                        m_bOwn = true;
                     }
                     else { // No valid alternative colorspace
                         pAlterCS->ReleaseCS();
                         int32_t nDictComponents = pDict ? pDict->GetInteger(FX_BSTRC("N")) : 0;
                         if (nDictComponents != 1 && nDictComponents != 3 && nDictComponents != 4) {
-                            return FALSE;
+                            return false;
                         }
                         m_nComponents = nDictComponents;
                     }
@@ -633,7 +633,7 @@ FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
                     }
                     else {
                         m_pAlterCS = pAlterCS;
-                        m_bOwn = TRUE;
+                        m_bOwn = true;
                     }
                 }
             }
@@ -661,15 +661,15 @@ FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
             m_pRanges[i] = 0;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pProfile && m_pProfile->m_bsRGB) {
         R = pBuf[0];
         G = pBuf[1];
         B = pBuf[2];
-        return TRUE;
+        return true;
     }
     ICodec_IccModule *pIccModule = CPDF_ModuleMgr::Get()->GetIccModule();
     if (m_pProfile->m_pTransform == NULL || pIccModule == NULL) {
@@ -678,7 +678,7 @@ FX_BOOL CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLO
         } else {
             R = G = B = 0.0f;
         }
-        return TRUE;
+        return true;
     }
     FX_FLOAT rgb[3];
     pIccModule->SetComponents(m_nComponents);
@@ -686,31 +686,31 @@ FX_BOOL CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLO
     R = rgb[0];
     G = rgb[1];
     B = rgb[2];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_ICCBasedCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (m_nComponents != 4) {
-        return FALSE;
+        return false;
     }
     c = pBuf[0];
     m = pBuf[1];
     y = pBuf[2];
     k = pBuf[3];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ICCBasedCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
+bool CPDF_ICCBasedCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
 {
-    return FALSE;
+    return false;
 }
-void CPDF_ICCBasedCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_ICCBasedCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAlterCS) {
         m_pAlterCS->EnableStdConversion(bEnabled);
     }
 }
-void CPDF_ICCBasedCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_ICCBasedCS::TranslateImageLine(uint8_t* pDestBuf, const uint8_t* pSrcBuf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     if (m_pProfile->m_bsRGB) {
         ReverseRGB(pDestBuf, pSrcBuf, pixels);
@@ -765,10 +765,10 @@ public:
     }
     ~CPDF_IndexedCS() override;
 
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL	GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool	GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
     CPDF_ColorSpace* GetBaseCS() const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pBaseCS;
     CPDF_CountedColorSpace* m_pCountedBaseCS;
@@ -787,19 +787,19 @@ CPDF_IndexedCS::~CPDF_IndexedCS()
         m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
     }
 }
-FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     if (pArray->GetCount() < 4) {
-        return FALSE;
+        return false;
     }
     CPDF_Object* pBaseObj = pArray->GetElementValue(1);
     if (pBaseObj == m_pArray) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
     if (m_pBaseCS == NULL) {
-        return FALSE;
+        return false;
     }
     m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
     m_nBaseComponents = m_pBaseCS->CountComponents();
@@ -812,29 +812,29 @@ FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
     m_MaxIndex = pArray->GetInteger(2);
     CPDF_Object* pTableObj = pArray->GetElementValue(3);
     if (pTableObj == NULL) {
-        return FALSE;
+        return false;
     }
     if (pTableObj->GetType() == PDFOBJ_STRING) {
         m_Table = ((CPDF_String*)pTableObj)->GetString();
     } else if (pTableObj->GetType() == PDFOBJ_STREAM) {
         CPDF_StreamAcc acc;
-        acc.LoadAllData((CPDF_Stream*)pTableObj, FALSE);
+        acc.LoadAllData((CPDF_Stream*)pTableObj, false);
         m_Table = CFX_ByteStringC(acc.GetData(), acc.GetSize());
     }
-    return TRUE;
+    return true;
 }
 
-FX_BOOL CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     int index = (int32_t)(*pBuf);
     if (index < 0 || index > m_MaxIndex) {
-        return FALSE;
+        return false;
     }
     if (m_nBaseComponents) {
         if (index == INT_MAX || (index + 1) > INT_MAX / m_nBaseComponents ||
                 (index + 1)*m_nBaseComponents > (int)m_Table.GetLength()) {
             R = G = B = 0;
-            return FALSE;
+            return false;
         }
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> Comps(m_nBaseComponents);
@@ -844,13 +844,13 @@ FX_BOOL CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOA
         comps[i] = m_pCompMinMax[i * 2] + m_pCompMinMax[i * 2 + 1] * pTable[index * m_nBaseComponents + i] / 255;
     }
     m_pBaseCS->GetRGB(comps, R, G, B);
-    return TRUE;
+    return true;
 }
 CPDF_ColorSpace*CPDF_IndexedCS::GetBaseCS() const
 {
     return m_pBaseCS;
 }
-void CPDF_IndexedCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_IndexedCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pBaseCS) {
@@ -871,39 +871,39 @@ CPDF_PatternCS::~CPDF_PatternCS()
 	    m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
     }
 }
-FX_BOOL CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Object* pBaseCS = pArray->GetElementValue(1);
     if (pBaseCS == m_pArray) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
     m_pBaseCS = pDocPageData->GetColorSpace(pBaseCS, NULL);
     if (m_pBaseCS) {
         if (m_pBaseCS->GetFamily() == PDFCS_PATTERN) {
-            return FALSE;
+            return false;
         }
         m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
         m_nComponents = m_pBaseCS->CountComponents() + 1;
         if (m_pBaseCS->CountComponents() > MAX_PATTERN_COLORCOMPS) {
-            return FALSE;
+            return false;
         }
     } else {
         m_nComponents = 1;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pBaseCS) {
         ASSERT(m_pBaseCS->GetFamily() != PDFCS_PATTERN);
         PatternValue* pvalue = (PatternValue*)pBuf;
         if (m_pBaseCS->GetRGB(pvalue->m_Comps, R, G, B)) {
-            return TRUE;
+            return true;
         }
     }
     R = G = B = 0.75f;
-    return FALSE;
+    return false;
 }
 CPDF_ColorSpace* CPDF_PatternCS::GetBaseCS() const
 {
@@ -919,9 +919,9 @@ public:
     }
     ~CPDF_SeparationCS() override;
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pAltCS;
     CPDF_Function* m_pFunc;
@@ -940,7 +940,7 @@ void CPDF_SeparationCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOA
     min = 0;
     max = 1.0f;
 }
-FX_BOOL CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CFX_ByteString name = pArray->GetString(1);
     if (name == FX_BSTRC("None")) {
@@ -949,11 +949,11 @@ FX_BOOL CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
         m_Type = Colorant;
         CPDF_Object* pAltCS = pArray->GetElementValue(2);
         if (pAltCS == m_pArray) {
-            return FALSE;
+            return false;
         }
         m_pAltCS = Load(pDoc, pAltCS);
         if (!m_pAltCS) {
-            return FALSE;
+            return false;
         }
         CPDF_Object* pFuncObj = pArray->GetElementValue(3);
         if (pFuncObj && pFuncObj->GetType() != PDFOBJ_NAME) {
@@ -964,16 +964,16 @@ FX_BOOL CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
             m_pFunc = NULL;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_Type == None) {
-        return FALSE;
+        return false;
     }
     if (m_pFunc == NULL) {
         if (m_pAltCS == NULL) {
-            return FALSE;
+            return false;
         }
         int nComps = m_pAltCS->CountComponents();
         CFX_FixedBufGrow<FX_FLOAT, 16> results(nComps);
@@ -981,22 +981,22 @@ FX_BOOL CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_F
             results[i] = *pBuf;
         }
         m_pAltCS->GetRGB(results, R, G, B);
-        return TRUE;
+        return true;
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
     int nresults = 0;
     m_pFunc->Call(pBuf, 1, results, nresults);
     if (nresults == 0) {
-        return FALSE;
+        return false;
     }
     if (m_pAltCS) {
         m_pAltCS->GetRGB(results, R, G, B);
-        return TRUE;
+        return true;
     }
     R = G = B = 0;
-    return FALSE;
+    return false;
 }
-void CPDF_SeparationCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_SeparationCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAltCS) {
@@ -1013,9 +1013,9 @@ public:
     }
     ~CPDF_DeviceNCS() override;
     void GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
-    void EnableStdConversion(FX_BOOL bEnabled) override;
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const override;
+    void EnableStdConversion(bool bEnabled) override;
 
     CPDF_ColorSpace* m_pAltCS;
     CPDF_Function* m_pFunc;
@@ -1033,45 +1033,45 @@ void CPDF_DeviceNCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT&
     min = 0;
     max = 1.0f;
 }
-FX_BOOL CPDF_DeviceNCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
+bool CPDF_DeviceNCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
 {
     CPDF_Object* pObj = pArray->GetElementValue(1);
     if (!pObj) {
-        return FALSE;
+        return false;
     }
     if (pObj->GetType() != PDFOBJ_ARRAY) {
-        return FALSE;
+        return false;
     }
     m_nComponents = ((CPDF_Array*)pObj)->GetCount();
     CPDF_Object* pAltCS = pArray->GetElementValue(2);
     if (!pAltCS || pAltCS == m_pArray) {
-        return FALSE;
+        return false;
     }
     m_pAltCS = Load(pDoc, pAltCS);
     m_pFunc = CPDF_Function::Load(pArray->GetElementValue(3));
     if (m_pAltCS == NULL || m_pFunc == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
+bool CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
 {
     if (m_pFunc == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
     int nresults = 0;
     m_pFunc->Call(pBuf, m_nComponents, results, nresults);
     if (nresults == 0) {
-        return FALSE;
+        return false;
     }
     m_pAltCS->GetRGB(results, R, G, B);
-    return TRUE;
+    return true;
 }
-void CPDF_DeviceNCS::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_DeviceNCS::EnableStdConversion(bool bEnabled)
 {
     CPDF_ColorSpace::EnableStdConversion(bEnabled);
     if (m_pAltCS) {
@@ -1197,33 +1197,33 @@ FX_FLOAT* CPDF_ColorSpace::CreateBuf()
     uint8_t* pBuf = FX_Alloc(uint8_t, size);
     return (FX_FLOAT*)pBuf;
 }
-FX_BOOL CPDF_ColorSpace::sRGB() const
+bool CPDF_ColorSpace::sRGB() const
 {
     if (m_Family == PDFCS_DEVICERGB) {
-        return TRUE;
+        return true;
     }
     if (m_Family != PDFCS_ICCBASED) {
-        return FALSE;
+        return false;
     }
     CPDF_ICCBasedCS* pCS = (CPDF_ICCBasedCS*)this;
     return pCS->m_pProfile->m_bsRGB;
 }
-FX_BOOL CPDF_ColorSpace::GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
+bool CPDF_ColorSpace::GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
 {
     if (v_GetCMYK(pBuf, c, m, y, k)) {
-        return TRUE;
+        return true;
     }
     FX_FLOAT R, G, B;
     if (!GetRGB(pBuf, R, G, B)) {
-        return FALSE;
+        return false;
     }
     sRGB_to_AdobeCMYK(R, G, B, c, m, y, k);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ColorSpace::SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
+bool CPDF_ColorSpace::SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
 {
     if (v_SetCMYK(pBuf, c, m, y, k)) {
-        return TRUE;
+        return true;
     }
     FX_FLOAT R, G, B;
     AdobeCMYK_to_sRGB(c, m, y, k, R, G, B);
@@ -1247,7 +1247,7 @@ int CPDF_ColorSpace::GetMaxIndex() const
     CPDF_IndexedCS* pCS = (CPDF_IndexedCS*)this;
     return pCS->m_MaxIndex;
 }
-void CPDF_ColorSpace::TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_buf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
+void CPDF_ColorSpace::TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_buf, int pixels, int image_width, int image_height, bool bTransMask) const
 {
     CFX_FixedBufGrow<FX_FLOAT, 16> srcbuf(m_nComponents);
     FX_FLOAT* src = srcbuf;
@@ -1265,7 +1265,7 @@ void CPDF_ColorSpace::TranslateImageLine(uint8_t* dest_buf, const uint8_t* src_b
         *dest_buf ++ = (int32_t)(R * 255);
     }
 }
-void CPDF_ColorSpace::EnableStdConversion(FX_BOOL bEnabled)
+void CPDF_ColorSpace::EnableStdConversion(bool bEnabled)
 {
     if (bEnabled) {
         m_dwStdConversion ++;
@@ -1397,23 +1397,23 @@ void CPDF_Color::Copy(const CPDF_Color* pSrc)
     if (m_pCS->GetFamily() == PDFCS_PATTERN) {
         PatternValue* pvalue = (PatternValue*)m_pBuffer;
         if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
-            pvalue->m_pPattern = pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(pvalue->m_pPattern->m_pPatternObj, FALSE, &pvalue->m_pPattern->m_ParentMatrix);
+            pvalue->m_pPattern = pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(pvalue->m_pPattern->m_pPatternObj, false, &pvalue->m_pPattern->m_ParentMatrix);
         }
     }
 }
-FX_BOOL CPDF_Color::GetRGB(int& R, int& G, int& B) const
+bool CPDF_Color::GetRGB(int& R, int& G, int& B) const
 {
     if (m_pCS == NULL || m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT r=0.0f, g=0.0f, b=0.0f;
     if (!m_pCS->GetRGB(m_pBuffer, r, g, b)) {
-        return FALSE;
+        return false;
     }
     R = (int32_t)(r * 255 + 0.5f);
     G = (int32_t)(g * 255 + 0.5f);
     B = (int32_t)(b * 255 + 0.5f);
-    return TRUE;
+    return true;
 }
 CPDF_Pattern* CPDF_Color::GetPattern() const
 {
@@ -1438,10 +1438,10 @@ FX_FLOAT* CPDF_Color::GetPatternColor() const
     PatternValue* pvalue = (PatternValue*)m_pBuffer;
     return pvalue->m_nComps ? pvalue->m_Comps : NULL;
 }
-FX_BOOL CPDF_Color::IsEqual(const CPDF_Color& other) const
+bool CPDF_Color::IsEqual(const CPDF_Color& other) const
 {
     if (m_pCS != other.m_pCS || m_pCS == NULL) {
-        return FALSE;
+        return false;
     }
     return FXSYS_memcmp(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
 }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_doc.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_doc.cpp
index 05233a12a4..568863a89b 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_doc.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_doc.cpp
@@ -78,7 +78,7 @@ void CPDF_PageModule::ReleaseDoc(CPDF_Document* pDoc)
 }
 void CPDF_PageModule::ClearDoc(CPDF_Document* pDoc)
 {
-    pDoc->GetPageData()->Clear(FALSE);
+    pDoc->GetPageData()->Clear(false);
 }
 void CPDF_PageModule::NotifyCJKAvailable()
 {
@@ -88,7 +88,7 @@ void CPDF_PageModule::NotifyCJKAvailable()
 CPDF_Font* CPDF_Document::LoadFont(CPDF_Dictionary* pFontDict)
 {
     ASSERT(pFontDict);
-    return GetValidatePageData()->GetFont(pFontDict, FALSE);
+    return GetValidatePageData()->GetFont(pFontDict, false);
 }
 
 CPDF_StreamAcc* CPDF_Document::LoadFontFile(CPDF_Stream* pStream)
@@ -101,7 +101,7 @@ CPDF_ColorSpace* CPDF_Document::LoadColorSpace(CPDF_Object* pCSObj, CPDF_Diction
 {
     return GetValidatePageData()->GetColorSpace(pCSObj, pResources);
 }
-CPDF_Pattern* CPDF_Document::LoadPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
+CPDF_Pattern* CPDF_Document::LoadPattern(CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* matrix)
 {
     return GetValidatePageData()->GetPattern(pPatternObj, bShading, matrix);
 }
@@ -126,14 +126,14 @@ void CPDF_Document::RemoveColorSpaceFromPageData(CPDF_Object* pCSObj)
 }
 CPDF_DocPageData::CPDF_DocPageData(CPDF_Document* pPDFDoc)
     : m_pPDFDoc(pPDFDoc),
-      m_bForceClear(FALSE)
+      m_bForceClear(false)
 {
 }
 
 CPDF_DocPageData::~CPDF_DocPageData()
 {
-    Clear(FALSE);
-    Clear(TRUE);
+    Clear(false);
+    Clear(true);
 
     for (auto& it : m_PatternMap)
         delete it.second;
@@ -148,7 +148,7 @@ CPDF_DocPageData::~CPDF_DocPageData()
     m_ColorSpaceMap.clear();
 }
 
-void CPDF_DocPageData::Clear(FX_BOOL bForceRelease)
+void CPDF_DocPageData::Clear(bool bForceRelease)
 {
     m_bForceClear = bForceRelease;
 
@@ -235,7 +235,7 @@ void CPDF_DocPageData::Clear(FX_BOOL bForceRelease)
     }
 }
 
-CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict, FX_BOOL findOnly)
+CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict, bool findOnly)
 {
     if (!pFontDict) {
         return NULL;
@@ -432,7 +432,7 @@ void CPDF_DocPageData::ReleaseColorSpace(CPDF_Object* pColorSpace)
     }
 }
 
-CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
+CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* matrix)
 {
     if (!pPatternObj)
         return nullptr;
@@ -455,7 +455,7 @@ CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, FX_BOOL bSh
             if (type == 1) {
                 pPattern = new CPDF_TilingPattern(m_pPDFDoc, pPatternObj, matrix);
             } else if (type == 2) {
-                pPattern = new CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, FALSE, matrix);
+                pPattern = new CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, false, matrix);
             }
         }
     }
@@ -501,7 +501,7 @@ CPDF_Image* CPDF_DocPageData::GetImage(CPDF_Object* pImageStream)
     }
 
     CPDF_Image* pImage = new CPDF_Image(m_pPDFDoc);
-    pImage->LoadImageF((CPDF_Stream*)pImageStream, FALSE);
+    pImage->LoadImageF((CPDF_Stream*)pImageStream, false);
 
     CPDF_CountedImage* imageData = new CPDF_CountedImage(pImage);
     m_ImageMap[dwImageObjNum] = imageData;
@@ -540,7 +540,7 @@ CPDF_IccProfile* CPDF_DocPageData::GetIccProfile(CPDF_Stream* pIccProfileStream)
     }
 
     CPDF_StreamAcc stream;
-    stream.LoadAllData(pIccProfileStream, FALSE);
+    stream.LoadAllData(pIccProfileStream, false);
     uint8_t digest[20];
     CPDF_Stream* pCopiedStream = nullptr;
     CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
@@ -590,14 +590,14 @@ CPDF_StreamAcc* CPDF_DocPageData::GetFontFileStreamAcc(CPDF_Stream* pFontStream)
         org_size = 0;
 
     CPDF_StreamAcc* pFontFile = new CPDF_StreamAcc;
-    pFontFile->LoadAllData(pFontStream, FALSE, org_size);
+    pFontFile->LoadAllData(pFontStream, false, org_size);
 
     CPDF_CountedStreamAcc* ftData = new CPDF_CountedStreamAcc(pFontFile);
     m_FontFileMap[pFontStream] = ftData;
     return ftData->AddRef();
 }
 
-void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, FX_BOOL bForce)
+void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, bool bForce)
 {
     if (!pFontStream)
         return;
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
index c961f8b20f..a92219d268 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_func.cpp
@@ -25,8 +25,8 @@ class CPDF_PSProc
 {
 public:
     ~CPDF_PSProc();
-    FX_BOOL	Parse(CPDF_SimpleParser& parser);
-    FX_BOOL	Execute(CPDF_PSEngine* pEngine);
+    bool	Parse(CPDF_SimpleParser& parser);
+    bool	Execute(CPDF_PSEngine* pEngine);
     CFX_PtrArray		m_Operators;
 };
 #define PSENGINE_STACKSIZE 100
@@ -35,12 +35,12 @@ class CPDF_PSEngine
 public:
     CPDF_PSEngine();
     ~CPDF_PSEngine();
-    FX_BOOL	Parse(const FX_CHAR* string, int size);
-    FX_BOOL	Execute()
+    bool	Parse(const FX_CHAR* string, int size);
+    bool	Execute()
     {
         return m_MainProc.Execute(this);
     }
-    FX_BOOL	DoOperator(PDF_PSOP op);
+    bool	DoOperator(PDF_PSOP op);
     void	Reset()
     {
         m_StackCount = 0;
@@ -73,7 +73,7 @@ CPDF_PSProc::~CPDF_PSProc()
         }
     }
 }
-FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
+bool CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
 {
     int size = m_Operators.GetSize();
     for (int i = 0; i < size; i ++) {
@@ -85,7 +85,7 @@ FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
             i ++;
         } else if (op == PSOP_IF) {
             if (i < 2 || m_Operators[i - 2] != (void*)PSOP_PROC) {
-                return FALSE;
+                return false;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
@@ -93,7 +93,7 @@ FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
         } else if (op == PSOP_IFELSE) {
             if (i < 4 || m_Operators[i - 2] != (void*)PSOP_PROC ||
                     m_Operators[i - 4] != (void*)PSOP_PROC) {
-                return FALSE;
+                return false;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);
@@ -104,7 +104,7 @@ FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
             pEngine->DoOperator(op);
         }
     }
-    return TRUE;
+    return true;
 }
 CPDF_PSEngine::CPDF_PSEngine()
 {
@@ -145,31 +145,31 @@ const struct _PDF_PSOpName {
     {"copy", PSOP_COPY}, {"index", PSOP_INDEX}, {"roll", PSOP_ROLL},
     {NULL, PSOP_PROC}
 };
-FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
+bool CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
 {
     CPDF_SimpleParser parser((uint8_t*)string, size);
     CFX_ByteStringC word = parser.GetWord();
     if (word != FX_BSTRC("{")) {
-        return FALSE;
+        return false;
     }
     return m_MainProc.Parse(parser);
 }
-FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
+bool CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
 {
     while (1) {
         CFX_ByteStringC word = parser.GetWord();
         if (word.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (word == FX_BSTRC("}")) {
-            return TRUE;
+            return true;
         }
         if (word == FX_BSTRC("{")) {
             CPDF_PSProc* pProc = new CPDF_PSProc;
             m_Operators.Add((void*)PSOP_PROC);
             m_Operators.Add(pProc);
             if (!pProc->Parse(parser)) {
-                return FALSE;
+                return false;
             }
         } else {
             int i = 0;
@@ -190,7 +190,7 @@ FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
     }
 }
 #define PI 3.1415926535897932384626433832795f
-FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
+bool CPDF_PSEngine::DoOperator(PDF_PSOP op)
 {
     int i1, i2;
     FX_FLOAT d1, d2;
@@ -418,7 +418,7 @@ FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
         default:
             break;
     }
-    return TRUE;
+    return true;
 }
 static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)
 {
@@ -445,8 +445,8 @@ class CPDF_SampledFunc : public CPDF_Function
 public:
     CPDF_SampledFunc();
     virtual ~CPDF_SampledFunc();
-    virtual FX_BOOL		v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool		v_Init(CPDF_Object* pObj);
+    virtual bool		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     SampleEncodeInfo*	m_pEncodeInfo;
     SampleDecodeInfo*	m_pDecodeInfo;
     FX_DWORD	m_nBitsPerSample;
@@ -469,10 +469,10 @@ CPDF_SampledFunc::~CPDF_SampledFunc()
         FX_Free(m_pDecodeInfo);
     }
 }
-FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
 {
     if (pObj->GetType() != PDFOBJ_STREAM) {
-        return FALSE;
+        return false;
     }
     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
     CPDF_Dictionary* pDict = pStream->GetDict();
@@ -481,11 +481,11 @@ FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
     CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
     m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
     if (m_nBitsPerSample > 32) {
-        return FALSE;
+        return false;
     }
     m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
     m_pSampleStream = new CPDF_StreamAcc;
-    m_pSampleStream->LoadAllData(pStream, FALSE);
+    m_pSampleStream->LoadAllData(pStream, false);
     m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
     FX_SAFE_DWORD nTotalSampleBits = 1;
     for (int i = 0; i < m_nInputs; i ++) {
@@ -514,7 +514,7 @@ FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
     if (!nTotalSampleBytes.IsValid() ||
         nTotalSampleBytes.ValueOrDie() == 0 ||
         nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
-        return FALSE;
+        return false;
     }
     m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
     for (int i = 0; i < m_nOutputs; i ++) {
@@ -526,9 +526,9 @@ FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
             m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+bool CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
 {
     int pos = 0;
     CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);
@@ -555,21 +555,21 @@ FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
     FX_SAFE_INT32 bits_to_output = m_nOutputs;
     bits_to_output *= m_nBitsPerSample;
     if (!bits_to_output.IsValid()) {
-        return FALSE;
+        return false;
     }
     FX_SAFE_INT32 bitpos = pos;
     bitpos *= bits_to_output.ValueOrDie();
     if (!bitpos.IsValid()) {
-        return FALSE;
+        return false;
     }
     FX_SAFE_INT32 range_check = bitpos;
     range_check += bits_to_output.ValueOrDie();
     if (!range_check.IsValid()) {
-        return FALSE;
+        return false;
     }
     const uint8_t* pSampleData = m_pSampleStream->GetData();
     if (!pSampleData) {
-        return FALSE;
+        return false;
     }
     for (int j = 0; j < m_nOutputs; j ++) {
         FX_DWORD sample = _GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample, m_nBitsPerSample);
@@ -586,7 +586,7 @@ FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
                 bitpos2 += j;
                 bitpos2 *= m_nBitsPerSample;
                 if (!bitpos2.IsValid()) {
-                    return FALSE;
+                    return false;
                 }
                 FX_DWORD sample1 = _GetBits32(pSampleData, bitpos2.ValueOrDie(), m_nBitsPerSample);
                 encoded += (encoded_input[i] - index[i]) * ((FX_FLOAT)sample1 - (FX_FLOAT)sample);
@@ -595,23 +595,23 @@ FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
         results[j] = PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
                                      m_pDecodeInfo[j].decode_min, m_pDecodeInfo[j].decode_max);
     }
-    return TRUE;
+    return true;
 }
 class CPDF_PSFunc : public CPDF_Function
 {
 public:
-    virtual FX_BOOL		v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool		v_Init(CPDF_Object* pObj);
+    virtual bool		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     CPDF_PSEngine m_PS;
 };
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_PSFunc::v_Init(CPDF_Object* pObj)
 {
     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
     CPDF_StreamAcc acc;
-    acc.LoadAllData(pStream, FALSE);
+    acc.LoadAllData(pStream, false);
     return m_PS.Parse((const FX_CHAR*)acc.GetData(), acc.GetSize());
 }
-FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+bool CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
 {
     CPDF_PSEngine& PS = (CPDF_PSEngine&)m_PS;
     PS.Reset();
@@ -621,20 +621,20 @@ FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
     }
     PS.Execute();
     if (PS.GetStackSize() < m_nOutputs) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nOutputs; i ++) {
         results[m_nOutputs - i - 1] = PS.Pop();
     }
-    return TRUE;
+    return true;
 }
 class CPDF_ExpIntFunc : public CPDF_Function
 {
 public:
     CPDF_ExpIntFunc();
     virtual ~CPDF_ExpIntFunc();
-    virtual FX_BOOL		v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool		v_Init(CPDF_Object* pObj);
+    virtual bool		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     FX_FLOAT	m_Exponent;
     FX_FLOAT*	m_pBeginValues;
     FX_FLOAT*	m_pEndValues;
@@ -654,11 +654,11 @@ CPDF_ExpIntFunc::~CPDF_ExpIntFunc()
         FX_Free(m_pEndValues);
     }
 }
-FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
 {
     CPDF_Dictionary* pDict = pObj->GetDict();
     if (pDict == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
     if (m_nOutputs == 0) {
@@ -677,27 +677,27 @@ FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
     m_Exponent = pDict->GetFloat(FX_BSTRC("N"));
     m_nOrigOutputs = m_nOutputs;
     if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
-        return FALSE;
+        return false;
     }
     m_nOutputs *= m_nInputs;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
+bool CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const
 {
     for (int i = 0; i < m_nInputs; i ++)
         for (int j = 0; j < m_nOrigOutputs; j ++) {
             results[i * m_nOrigOutputs + j] = m_pBeginValues[j] + (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *
                                               (m_pEndValues[j] - m_pBeginValues[j]);
         }
-    return TRUE;
+    return true;
 }
 class CPDF_StitchFunc : public CPDF_Function
 {
 public:
     CPDF_StitchFunc();
     virtual ~CPDF_StitchFunc();
-    virtual FX_BOOL		v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool		v_Init(CPDF_Object* pObj);
+    virtual bool		v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     int			m_nSubs;
     CPDF_Function** m_pSubFunctions;
     FX_FLOAT*	m_pBounds;
@@ -724,19 +724,19 @@ CPDF_StitchFunc::~CPDF_StitchFunc()
         FX_Free(m_pEncode);
     }
 }
-FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
 {
     CPDF_Dictionary* pDict = pObj->GetDict();
     if (pDict == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     m_nSubs = pArray->GetCount();
     if (m_nSubs == 0) {
-        return FALSE;
+        return false;
     }
     m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
     m_nOutputs = 0;
@@ -744,11 +744,11 @@ FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
     for (i = 0; i < m_nSubs; i ++) {
         CPDF_Object* pSub = pArray->GetElementValue(i);
         if (pSub == pObj) {
-            return FALSE;
+            return false;
         }
         m_pSubFunctions[i] = CPDF_Function::Load(pSub);
         if (m_pSubFunctions[i] == NULL) {
-            return FALSE;
+            return false;
         }
         if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
             m_nOutputs = m_pSubFunctions[i]->CountOutputs();
@@ -758,7 +758,7 @@ FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
     m_pBounds[0] = m_pDomains[0];
     pArray = pDict->GetArray(FX_BSTRC("Bounds"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nSubs - 1; i ++) {
         m_pBounds[i + 1] = pArray->GetFloat(i);
@@ -767,14 +767,14 @@ FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
     m_pEncode = FX_Alloc2D(FX_FLOAT, m_nSubs, 2);
     pArray = pDict->GetArray(FX_BSTRC("Encode"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nSubs * 2; i ++) {
         m_pEncode[i] = pArray->GetFloat(i);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const
+bool CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const
 {
     FX_FLOAT input = inputs[0];
     int i;
@@ -783,12 +783,12 @@ FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const
             break;
         }
     if (m_pSubFunctions[i] == NULL) {
-        return FALSE;
+        return false;
     }
     input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1], m_pEncode[i * 2], m_pEncode[i * 2 + 1]);
     int nresults;
     m_pSubFunctions[i]->Call(&input, m_nInputs, outputs, nresults);
-    return TRUE;
+    return true;
 }
 CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj)
 {
@@ -837,7 +837,7 @@ CPDF_Function::~CPDF_Function()
         m_pRanges = NULL;
     }
 }
-FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
+bool CPDF_Function::Init(CPDF_Object* pObj)
 {
     CPDF_Dictionary* pDict;
     if (pObj->GetType() == PDFOBJ_STREAM) {
@@ -847,11 +847,11 @@ FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
     }
     CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
     if (pDomains == NULL) {
-        return FALSE;
+        return false;
     }
     m_nInputs = pDomains->GetCount() / 2;
     if (m_nInputs == 0) {
-        return FALSE;
+        return false;
     }
     m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2);
     for (int i = 0; i < m_nInputs * 2; i ++) {
@@ -868,7 +868,7 @@ FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
     }
     FX_DWORD old_outputs = m_nOutputs;
     if (!v_Init(pObj)) {
-        return FALSE;
+        return false;
     }
     if (m_pRanges && m_nOutputs > (int)old_outputs) {
         m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
@@ -876,12 +876,12 @@ FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
             FXSYS_memset(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const
+bool CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const
 {
     if (m_nInputs != ninputs) {
-        return FALSE;
+        return false;
     }
     nresults = m_nOutputs;
     for (int i = 0; i < m_nInputs; i ++) {
@@ -901,5 +901,5 @@ FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, in
             }
         }
     }
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
index b4d030e679..3264be42c6 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_graph_state.cpp
@@ -97,7 +97,7 @@ void CPDF_ClipPathData::SetCount(int path_count, int text_count)
 CPDF_Rect CPDF_ClipPath::GetClipBox() const
 {
     CPDF_Rect rect;
-    FX_BOOL bStarted = FALSE;
+    bool bStarted = false;
     int count = GetPathCount();
     if (count) {
         rect = GetPath(0).GetBoundingBox();
@@ -105,26 +105,26 @@ CPDF_Rect CPDF_ClipPath::GetClipBox() const
             CPDF_Rect path_rect = GetPath(i).GetBoundingBox();
             rect.Intersect(path_rect);
         }
-        bStarted = TRUE;
+        bStarted = true;
     }
     count = GetTextCount();
     if (count) {
         CPDF_Rect layer_rect;
-        FX_BOOL bLayerStarted = FALSE;
+        bool bLayerStarted = false;
         for (int i = 0; i < count; i ++) {
             CPDF_TextObject* pTextObj = GetText(i);
             if (pTextObj == NULL) {
                 if (!bStarted) {
                     rect = layer_rect;
-                    bStarted = TRUE;
+                    bStarted = true;
                 } else {
                     rect.Intersect(layer_rect);
                 }
-                bLayerStarted = FALSE;
+                bLayerStarted = false;
             } else {
                 if (!bLayerStarted) {
                     layer_rect = pTextObj->GetBBox(NULL);
-                    bLayerStarted = TRUE;
+                    bLayerStarted = true;
                 } else {
                     layer_rect.Union(pTextObj->GetBBox(NULL));
                 }
@@ -133,7 +133,7 @@ CPDF_Rect CPDF_ClipPath::GetClipBox() const
     }
     return rect;
 }
-void CPDF_ClipPath::AppendPath(CPDF_Path path, int type, FX_BOOL bAutoMerge)
+void CPDF_ClipPath::AppendPath(CPDF_Path path, int type, bool bAutoMerge)
 {
     CPDF_ClipPathData* pData = GetModify();
     if (pData->m_PathCount && bAutoMerge) {
@@ -256,7 +256,7 @@ void CPDF_ColorState::SetFillPattern(CPDF_Pattern* pPattern, FX_FLOAT* pValue, i
     CPDF_ColorStateData* pData = GetModify();
     pData->m_FillColor.SetValue(pPattern, pValue, nValues);
     int R, G, B;
-    FX_BOOL ret = pData->m_FillColor.GetRGB(R, G, B);
+    bool ret = pData->m_FillColor.GetRGB(R, G, B);
     if (pPattern->m_PatternType == 1 && ((CPDF_TilingPattern*)pPattern)->m_bColored && !ret) {
         pData->m_FillRGB = 0x00BFBFBF;
         return;
@@ -268,7 +268,7 @@ void CPDF_ColorState::SetStrokePattern(CPDF_Pattern* pPattern, FX_FLOAT* pValue,
     CPDF_ColorStateData* pData = GetModify();
     pData->m_StrokeColor.SetValue(pPattern, pValue, nValues);
     int R, G, B;
-    FX_BOOL ret = pData->m_StrokeColor.GetRGB(R, G, B);
+    bool ret = pData->m_StrokeColor.GetRGB(R, G, B);
     if (pPattern->m_PatternType == 1 && ((CPDF_TilingPattern*)pPattern)->m_bColored && !ret) {
         pData->m_StrokeRGB = 0x00BFBFBF;
         return;
@@ -295,7 +295,7 @@ CPDF_TextStateData::CPDF_TextStateData(const CPDF_TextStateData& src)
     }
     FXSYS_memcpy(this, &src, sizeof(CPDF_TextStateData));
     if (m_pDocument && m_pFont) {
-        m_pFont = m_pDocument->GetPageData()->GetFont(m_pFont->GetFontDict(), FALSE);
+        m_pFont = m_pDocument->GetPageData()->GetFont(m_pFont->GetFontDict(), false);
     }
 }
 CPDF_TextStateData::~CPDF_TextStateData()
@@ -545,7 +545,7 @@ void CPDF_AllStates::ProcessExtGS(CPDF_Dictionary* pGS, CPDF_StreamContentParser
                     }
                     pGeneralState->SetBlendMode(mode);
                     if (pGeneralState->m_BlendType > FXDIB_BLEND_MULTIPLY) {
-                        pParser->GetObjectList()->m_bBackgroundAlphaNeeded = TRUE;
+                        pParser->GetObjectList()->m_bBackgroundAlphaNeeded = true;
                     }
                     break;
                 }
@@ -631,12 +631,12 @@ CPDF_ContentMarkItem::~CPDF_ContentMarkItem()
         ((CPDF_Dictionary*)m_pParam)->Release();
     }
 }
-FX_BOOL	CPDF_ContentMarkItem::HasMCID() const
+bool	CPDF_ContentMarkItem::HasMCID() const
 {
     if (m_pParam && (m_ParamType == DirectDict || m_ParamType == PropertiesDict)) {
         return ((CPDF_Dictionary *)m_pParam)->KeyExist(FX_BSTRC("MCID"));
     }
-    return FALSE;
+    return false;
 }
 CPDF_ContentMarkData::CPDF_ContentMarkData(const CPDF_ContentMarkData& src)
 {
@@ -658,7 +658,7 @@ int CPDF_ContentMarkData::GetMCID() const
     }
     return -1;
 }
-void CPDF_ContentMarkData::AddMark(const CFX_ByteString& name, CPDF_Dictionary* pDict, FX_BOOL bDirect)
+void CPDF_ContentMarkData::AddMark(const CFX_ByteString& name, CPDF_Dictionary* pDict, bool bDirect)
 {
     CPDF_ContentMarkItem& item = m_Marks.Add();
     item.SetName(name);
@@ -676,23 +676,23 @@ void CPDF_ContentMarkData::DeleteLastMark()
     }
     m_Marks.RemoveAt(size - 1);
 }
-FX_BOOL CPDF_ContentMark::HasMark(const CFX_ByteStringC& mark) const
+bool CPDF_ContentMark::HasMark(const CFX_ByteStringC& mark) const
 {
     if (m_pObject == NULL) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < m_pObject->CountItems(); i ++) {
         CPDF_ContentMarkItem& item = m_pObject->GetItem(i);
         if (item.GetName() == mark) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ContentMark::LookupMark(const CFX_ByteStringC& mark, CPDF_Dictionary*& pDict) const
+bool CPDF_ContentMark::LookupMark(const CFX_ByteStringC& mark, CPDF_Dictionary*& pDict) const
 {
     if (m_pObject == NULL) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < m_pObject->CountItems(); i ++) {
         CPDF_ContentMarkItem& item = m_pObject->GetItem(i);
@@ -702,8 +702,8 @@ FX_BOOL CPDF_ContentMark::LookupMark(const CFX_ByteStringC& mark, CPDF_Dictionar
                     item.GetParamType() == CPDF_ContentMarkItem::DirectDict) {
                 pDict = (CPDF_Dictionary*)item.GetParam();
             }
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_image.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_image.cpp
index aabfd141d6..739a0bdf04 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_image.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_image.cpp
@@ -57,7 +57,7 @@ CPDF_Image* CPDF_Image::Clone()
     CPDF_Image* pImage = new CPDF_Image(m_pDocument);
     pImage->LoadImageF((CPDF_Stream*)((CPDF_Object*)m_pStream)->Clone(), m_bInline);
     if (m_bInline) {
-        CPDF_Dictionary *pInlineDict = (CPDF_Dictionary*)m_pInlineDict->Clone(TRUE);
+        CPDF_Dictionary *pInlineDict = (CPDF_Dictionary*)m_pInlineDict->Clone(true);
         pImage->SetInlineDict(pInlineDict);
     }
     return pImage;
@@ -67,7 +67,7 @@ CPDF_Image::CPDF_Image(CPDF_Document* pDoc)
     m_pDocument = pDoc;
     m_pStream = NULL;
     m_pOC = NULL;
-    m_bInline = FALSE;
+    m_bInline = false;
     m_pInlineDict = NULL;
     m_pDIBSource = NULL;
     m_pMask = NULL;
@@ -84,7 +84,7 @@ CPDF_Image::~CPDF_Image()
         }
     }
 }
-FX_BOOL CPDF_Image::LoadImageF(CPDF_Stream* pStream, FX_BOOL bInline)
+bool CPDF_Image::LoadImageF(CPDF_Stream* pStream, bool bInline)
 {
     m_pStream = pStream;
     if (m_bInline && m_pInlineDict) {
@@ -101,5 +101,5 @@ FX_BOOL CPDF_Image::LoadImageF(CPDF_Stream* pStream, FX_BOOL bInline)
     m_bInterpolate = pDict->GetInteger(FX_BSTRC("Interpolate"));
     m_Height = pDict->GetInteger(FX_BSTRC("Height"));
     m_Width = pDict->GetInteger(FX_BSTRC("Width"));
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
index 892e2153b7..b27f958d5e 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_parser.cpp
@@ -9,7 +9,7 @@
 #include "../../../include/fpdfapi/fpdf_serial.h"
 #include "pageint.h"
 
-#define REQUIRE_PARAMS(count) if (m_ParamCount != count) { m_bAbort = TRUE; return; }
+#define REQUIRE_PARAMS(count) if (m_ParamCount != count) { m_bAbort = true; return; }
 
 CPDF_StreamContentParser::CPDF_StreamContentParser(
     CPDF_Document* pDocument,
@@ -30,7 +30,7 @@ CPDF_StreamContentParser::CPDF_StreamContentParser(
       m_Level(level),
       m_ParamStartPos(0),
       m_ParamCount(0),
-      m_bAbort(FALSE),
+      m_bAbort(false),
       m_pCurStates(new CPDF_AllStates),
       m_pLastTextObject(nullptr),
       m_DefFontSize(0),
@@ -43,9 +43,9 @@ CPDF_StreamContentParser::CPDF_StreamContentParser(
       m_pLastImage(nullptr),
       m_pLastImageDict(nullptr),
       m_pLastCloneImageDict(nullptr),
-      m_bReleaseLastDict(TRUE),
-      m_bColored(FALSE),
-      m_bResourceMissing(FALSE)
+      m_bReleaseLastDict(true),
+      m_bColored(false),
+      m_bResourceMissing(false)
 {
     if (pmtContentToUser) {
         m_mtContentToUser = *pmtContentToUser;
@@ -183,7 +183,7 @@ CPDF_Object* CPDF_StreamContentParser::GetObject(FX_DWORD index)
     if (param.m_Type == 0) {
         return param.m_pObject;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
     return NULL;
 }
 CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index)
@@ -226,7 +226,7 @@ FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index)
 {
     return GetNumber(index);
 }
-void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj, FX_BOOL bColor, FX_BOOL bText, FX_BOOL bGraph)
+void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj, bool bColor, bool bText, bool bGraph)
 {
     pObj->m_GeneralState = m_pCurStates->m_GeneralState;
     pObj->m_ClipPath = m_pCurStates->m_ClipPath;
@@ -318,7 +318,7 @@ const CPDF_StreamContentParser::OpCode CPDF_StreamContentParser::g_OpCodes[] =
     {FXBSTR_ID('w', 0, 0, 0),		&CPDF_StreamContentParser::Handle_SetLineWidth},
     {FXBSTR_ID('y', 0, 0, 0),		&CPDF_StreamContentParser::Handle_CurveTo_13},
 };
-FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op)
+bool CPDF_StreamContentParser::OnOperator(const FX_CHAR* op)
 {
     int i = 0;
     FX_DWORD opid = 0;
@@ -336,7 +336,7 @@ FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op)
         int compare = opid - g_OpCodes[middle].m_OpId;
         if (compare == 0) {
             (this->*g_OpCodes[middle].m_OpHandler)();
-            return TRUE;
+            return true;
         }
         if (compare < 0) {
             high = middle - 1;
@@ -352,14 +352,14 @@ void CPDF_StreamContentParser::Handle_CloseFillStrokePath()
         return;
     }
     Handle_ClosePath();
-    AddPathObject(FXFILL_WINDING, TRUE);
+    AddPathObject(FXFILL_WINDING, true);
 }
 void CPDF_StreamContentParser::Handle_FillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, TRUE);
+    AddPathObject(FXFILL_WINDING, true);
 }
 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath()
 {
@@ -367,14 +367,14 @@ void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath()
         return;
     }
     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
-    AddPathObject(FXFILL_ALTERNATE, TRUE);
+    AddPathObject(FXFILL_ALTERNATE, true);
 }
 void CPDF_StreamContentParser::Handle_EOFillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_ALTERNATE, TRUE);
+    AddPathObject(FXFILL_ALTERNATE, true);
 }
 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary()
 {
@@ -386,13 +386,13 @@ void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary()
     if (pProperty == NULL) {
         return;
     }
-    FX_BOOL bDirect = TRUE;
+    bool bDirect = true;
     if (pProperty->GetType() == PDFOBJ_NAME) {
         pProperty = FindResourceObj(FX_BSTRC("Properties"), pProperty->GetString());
         if (pProperty == NULL) {
             return;
         }
-        bDirect = FALSE;
+        bDirect = false;
     }
     if (pProperty->GetType() != PDFOBJ_DICTIONARY) {
         return;
@@ -405,7 +405,7 @@ void CPDF_StreamContentParser::Handle_BeginMarkedContent()
         return;
     }
     CFX_ByteString tag = GetString(0);
-    m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
+    m_CurContentMark.GetModify()->AddMark(tag, NULL, false);
 }
 struct _FX_BSTR {
     const FX_CHAR*	m_Ptr;
@@ -622,20 +622,20 @@ void CPDF_StreamContentParser::Handle_SetCharWidth()
 {
     m_Type3Data[0] = GetNumber(1);
     m_Type3Data[1] = GetNumber(0);
-    m_bColored = TRUE;
+    m_bColored = true;
 }
 void CPDF_StreamContentParser::Handle_SetCachedDevice()
 {
     for (int i = 0; i < 6; i ++) {
         m_Type3Data[i] = GetNumber(5 - i);
     }
-    m_bColored = FALSE;
+    m_bColored = false;
 }
 void CPDF_StreamContentParser::Handle_ExecuteXObject()
 {
     CFX_ByteString name = GetString(0);
     if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() && m_pLastImage->GetStream()->GetObjNum()) {
-        AddImage(NULL, m_pLastImage, FALSE);
+        AddImage(NULL, m_pLastImage, false);
         return;
     }
     if (m_Options.m_bTextOnly) {
@@ -673,14 +673,14 @@ void CPDF_StreamContentParser::Handle_ExecuteXObject()
                 }
             }
         }
-        FX_BOOL bForm;
+        bool bForm;
         if (m_pDocument->IsFormStream(((CPDF_Reference*)pRes)->GetRefObjNum(), bForm) && !bForm) {
             return;
         }
     }
     CPDF_Stream* pXObject = (CPDF_Stream*)FindResourceObj(FX_BSTRC("XObject"), name);
     if (pXObject == NULL || pXObject->GetType() != PDFOBJ_STREAM) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return;
     }
     CFX_ByteStringC type = pXObject->GetDict() ? pXObject->GetDict()->GetConstString(FX_BSTRC("Subtype")) : CFX_ByteStringC();
@@ -688,7 +688,7 @@ void CPDF_StreamContentParser::Handle_ExecuteXObject()
         if (m_Options.m_bTextOnly) {
             return;
         }
-        CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
+        CPDF_ImageObject* pObj = AddImage(pXObject, NULL, false);
         m_LastImageName = name;
         m_pLastImage = pObj->m_pImage;
     } else if (type == FX_BSTRC("Form")) {
@@ -719,10 +719,10 @@ void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream)
             m_pCurStates.get(), m_Level + 1);
         parser.m_pCurStates->m_CTM = form_matrix;
         if (ClipPath.NotNull()) {
-            parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, TRUE);
+            parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, true);
         }
         CPDF_StreamAcc stream;
-        stream.LoadAllData(pStream, FALSE);
+        stream.LoadAllData(pStream, false);
         if (stream.GetSize() == 0) {
             return;
         }
@@ -740,13 +740,13 @@ void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream)
     status.m_TextState = m_pCurStates->m_TextState;
     pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
     if (!m_pObjectList->m_bBackgroundAlphaNeeded && pFormObj->m_pForm->m_bBackgroundAlphaNeeded) {
-        m_pObjectList->m_bBackgroundAlphaNeeded = TRUE;
+        m_pObjectList->m_bBackgroundAlphaNeeded = true;
     }
     pFormObj->CalcBoundingBox();
-    SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
+    SetGraphicStates(pFormObj, true, true, true);
     m_pObjectList->m_ObjectList.AddTail(pFormObj);
 }
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, FX_BOOL bInline)
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, bool bInline)
 {
     if (pStream == NULL && pImage == NULL) {
         return NULL;
@@ -763,7 +763,7 @@ CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream, CPDF_
         pImageObj->m_pImage = new CPDF_Image(m_pDocument);
         pImageObj->m_pImage->LoadImageF(pStream, bInline);
     }
-    SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
+    SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), false, false);
     pImageObj->m_Matrix = ImageMatrix;
     pImageObj->CalcBoundingBox();
     m_pObjectList->m_ObjectList.AddTail(pImageObj);
@@ -817,21 +817,21 @@ void CPDF_StreamContentParser::Handle_FillPath()
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, FALSE);
+    AddPathObject(FXFILL_WINDING, false);
 }
 void CPDF_StreamContentParser::Handle_FillPathOld()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, FALSE);
+    AddPathObject(FXFILL_WINDING, false);
 }
 void CPDF_StreamContentParser::Handle_EOFillPath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_ALTERNATE, FALSE);
+    AddPathObject(FXFILL_ALTERNATE, false);
 }
 void CPDF_StreamContentParser::Handle_SetGray_Fill()
 {
@@ -850,7 +850,7 @@ void CPDF_StreamContentParser::Handle_SetExtendGraphState()
     CFX_ByteString name = GetString(0);
     CPDF_Dictionary* pGS = (CPDF_Dictionary*)FindResourceObj(FX_BSTRC("ExtGState"), name);
     if (pGS == NULL || pGS->GetType() != PDFOBJ_DICTIONARY) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return;
     }
     m_pCurStates->ProcessExtGS(pGS, this);
@@ -934,7 +934,7 @@ void CPDF_StreamContentParser::Handle_EndPath()
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(0, FALSE);
+    AddPathObject(0, false);
 }
 void CPDF_StreamContentParser::Handle_SaveGraphState()
 {
@@ -999,14 +999,14 @@ void CPDF_StreamContentParser::Handle_CloseStrokePath()
         return;
     }
     Handle_ClosePath();
-    AddPathObject(0, TRUE);
+    AddPathObject(0, true);
 }
 void CPDF_StreamContentParser::Handle_StrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(0, TRUE);
+    AddPathObject(0, true);
 }
 void CPDF_StreamContentParser::Handle_SetColor_Fill()
 {
@@ -1060,7 +1060,7 @@ void CPDF_StreamContentParser::Handle_SetColorPS_Fill()
         }
     }
     if (nvalues != nargs) {
-        CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
+        CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
         if (pPattern) {
             m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
         }
@@ -1093,7 +1093,7 @@ void CPDF_StreamContentParser::Handle_SetColorPS_Stroke()
         }
     }
     if (nvalues != nargs) {
-        CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
+        CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
         if (pPattern) {
             m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
         }
@@ -1111,7 +1111,7 @@ void CPDF_StreamContentParser::Handle_ShadeFill()
     if (m_Options.m_bTextOnly) {
         return;
     }
-    CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
+    CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
     if (pPattern == NULL) {
         return;
     }
@@ -1127,7 +1127,7 @@ void CPDF_StreamContentParser::Handle_ShadeFill()
     }
     CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
     pObj->m_pShading = pShading;
-    SetGraphicStates(pObj, FALSE, FALSE, FALSE);
+    SetGraphicStates(pObj, false, false, false);
     pObj->m_Matrix = m_pCurStates->m_CTM;
     pObj->m_Matrix.Concat(m_mtContentToUser);
     CFX_FloatRect bbox;
@@ -1206,7 +1206,7 @@ CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name)
 {
     CPDF_Dictionary* pFontDict = (CPDF_Dictionary*)FindResourceObj(FX_BSTRC("Font"), name);
     if (pFontDict == NULL || pFontDict->GetType() != PDFOBJ_DICTIONARY) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
     }
     CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
@@ -1238,17 +1238,17 @@ CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(const CFX_ByteString&
     }
     CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
     if (pCSObj == NULL) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return NULL;
     }
     return m_pDocument->LoadColorSpace(pCSObj);
 }
-CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name, FX_BOOL bShading)
+CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name, bool bShading)
 {
     CPDF_Object* pPattern = FindResourceObj(bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
     if (pPattern == NULL || (pPattern->GetType() != PDFOBJ_DICTIONARY &&
                              pPattern->GetType() != PDFOBJ_STREAM)) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return NULL;
     }
     return m_pDocument->LoadPattern(pPattern, bShading, &m_pCurStates->m_ParentMatrix);
@@ -1287,7 +1287,7 @@ void CPDF_StreamContentParser::AddTextObject(CFX_ByteString* pStrs, FX_FLOAT fIn
     }
     CPDF_TextObject* pText = new CPDF_TextObject;
     m_pLastTextObject = pText;
-    SetGraphicStates(pText, TRUE, TRUE, TRUE);
+    SetGraphicStates(pText, true, true, true);
     if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
         FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
         pCTM[0] = m_pCurStates->m_CTM.a;
@@ -1501,7 +1501,7 @@ void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag)
     m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
     m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
 }
-void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke)
+void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke)
 {
     int PathPointCount = m_PathPointCount, PathClipType = m_PathClipType;
     m_PathPointCount = 0;
@@ -1510,7 +1510,7 @@ void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke)
         if (PathPointCount && PathClipType) {
             CPDF_Path path;
             path.New()->AppendRect(0, 0, 0, 0);
-            m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
+            m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, true);
         }
         return;
     }
@@ -1529,7 +1529,7 @@ void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke)
         pPathObj->m_FillType = FillType;
         pPathObj->m_Path = Path;
         pPathObj->m_Matrix = matrix;
-        SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
+        SetGraphicStates(pPathObj, true, false, true);
         pPathObj->CalcBoundingBox();
         m_pObjectList->m_ObjectList.AddTail(pPathObj);
     }
@@ -1538,13 +1538,13 @@ void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke)
             Path.Transform(&matrix);
             matrix.SetIdentity();
         }
-        m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
+        m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, true);
     }
 }
 CFX_ByteString _FPDF_ByteStringFromHex(CFX_BinaryBuf& src_buf)
 {
     CFX_ByteTextBuf buf;
-    FX_BOOL bFirst = TRUE;
+    bool bFirst = true;
     int code = 0;
     const uint8_t* str = src_buf.GetBuffer();
     FX_DWORD size = src_buf.GetSize();
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
index 37ffea9742..399a4c754c 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.cpp
@@ -18,18 +18,18 @@ const FX_CHAR* const _PDF_OpCharType =
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII";
-FX_BOOL _PDF_HasInvalidOpChar(const FX_CHAR* op)
+bool _PDF_HasInvalidOpChar(const FX_CHAR* op)
 {
     if(!op) {
-        return FALSE;
+        return false;
     }
     uint8_t ch;
     while((ch = *op++)) {
         if(_PDF_OpCharType[ch] == 'I') {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 class CPDF_StreamParserAutoClearer {
   public:
@@ -60,7 +60,7 @@ FX_DWORD CPDF_StreamContentParser::Parse(const uint8_t* pData, FX_DWORD dwSize,
                 return m_pSyntax->GetPos();
             case CPDF_StreamParser::Keyword:
                 if(!OnOperator((char*)syntax.GetWordBuf()) && _PDF_HasInvalidOpChar((char*)syntax.GetWordBuf())) {
-                    m_bAbort = TRUE;
+                    m_bAbort = true;
                 }
                 if (m_bAbort) {
                     return m_pSyntax->GetPos();
@@ -143,7 +143,7 @@ void CPDF_StreamContentParser::Handle_BeginImage()
         return;
     }
     pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image"));
-    CPDF_ImageObject *pImgObj = AddImage(pStream, NULL, TRUE);
+    CPDF_ImageObject *pImgObj = AddImage(pStream, NULL, true);
     if (!pImgObj) {
         if (pStream) {
             pStream->Release();
@@ -159,7 +159,7 @@ void CPDF_StreamContentParser::ParsePathObject()
     int last_pos = m_pSyntax->GetPos();
     while (1) {
         CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
-        FX_BOOL bProcessed = TRUE;
+        bool bProcessed = true;
         switch (type) {
             case CPDF_StreamParser::EndOfData:
                 return;
@@ -198,7 +198,7 @@ void CPDF_StreamContentParser::ParsePathObject()
                                 nParams = 0;
                                 break;
                             default:
-                                bProcessed = FALSE;
+                                bProcessed = false;
                                 break;
                         }
                     } else if (len == 2) {
@@ -206,10 +206,10 @@ void CPDF_StreamContentParser::ParsePathObject()
                             AddPathRect(params[0], params[1], params[2], params[3]);
                             nParams = 0;
                         } else {
-                            bProcessed = FALSE;
+                            bProcessed = false;
                         }
                     } else {
-                        bProcessed = FALSE;
+                        bProcessed = false;
                     }
                     if (bProcessed) {
                         last_pos = m_pSyntax->GetPos();
@@ -220,14 +220,14 @@ void CPDF_StreamContentParser::ParsePathObject()
                     if (nParams == 6) {
                         break;
                     }
-                    FX_BOOL bInteger;
+                    bool bInteger;
                     int value;
                     FX_atonum(CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()), bInteger, &value);
                     params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
                     break;
                 }
             default:
-                bProcessed = FALSE;
+                bProcessed = false;
         }
         if (!bProcessed) {
             m_pSyntax->SetPos(last_pos);
@@ -279,7 +279,7 @@ ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(const uint8_t* src_buf, FX_DWOR
         const CPDF_Dictionary* pParams);
 FX_DWORD _A85Decode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 FX_DWORD _HexDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
-FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
+FX_DWORD FPDFAPI_FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
                                   FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf, FX_DWORD limit,
                                 int width, int height, CFX_ByteString& decoder,
@@ -296,10 +296,10 @@ FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf, FX_DWORD limit,
         return _HexDecode(src_buf, limit, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("FlateDecode") || decoder == FX_BSTRC("Fl")) {
-        return FPDFAPI_FlateOrLZWDecode(FALSE, src_buf, limit, pParam, dest_size, dest_buf, dest_size);
+        return FPDFAPI_FlateOrLZWDecode(false, src_buf, limit, pParam, dest_size, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {
-        return FPDFAPI_FlateOrLZWDecode(TRUE, src_buf, limit, pParam, 0, dest_buf, dest_size);
+        return FPDFAPI_FlateOrLZWDecode(true, src_buf, limit, pParam, 0, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("DCTDecode") || decoder == FX_BSTRC("DCT")) {
         ICodec_ScanlineDecoder* pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
@@ -313,7 +313,7 @@ FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf, FX_DWORD limit,
     dest_buf = 0;
     return (FX_DWORD) - 1;
 }
-CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, FX_BOOL bDecode)
+CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, bool bDecode)
 {
     if (m_Pos == m_Size) {
         return NULL;
@@ -447,7 +447,7 @@ CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement()
         m_pLastObj = NULL;
     }
     m_WordSize = 0;
-    FX_BOOL bIsNumber = TRUE;
+    bool bIsNumber = true;
     if (m_Pos >= m_Size) {
         return EndOfData;
     }
@@ -485,7 +485,7 @@ CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement()
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (type != 'N') {
-            bIsNumber = FALSE;
+            bIsNumber = false;
         }
         if (m_Size <= m_Pos) {
             break;
@@ -506,7 +506,7 @@ CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement()
     }
     if (m_WordSize == 4) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_TRUE) {
-            m_pLastObj = CPDF_Boolean::Create(TRUE);
+            m_pLastObj = CPDF_Boolean::Create(true);
             return Others;
         }
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_NULL) {
@@ -515,7 +515,7 @@ CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement()
         }
     } else if (m_WordSize == 5) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_FALS && m_WordBuffer[4] == 'e') {
-            m_pLastObj = CPDF_Boolean::Create(FALSE);
+            m_pLastObj = CPDF_Boolean::Create(false);
             return Others;
         }
     }
@@ -584,9 +584,9 @@ void CPDF_StreamParser::SkipPathObject()
         }
     }
 }
-CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOOL bInArray)
+CPDF_Object* CPDF_StreamParser::ReadNextObject(bool bAllowNestedArray, bool bInArray)
 {
-    FX_BOOL bIsNumber;
+    bool bIsNumber;
     GetNextWord(bIsNumber);
     if (m_WordSize == 0) {
         return NULL;
@@ -604,7 +604,7 @@ CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOO
     }
     if (first_char == '<') {
         if (m_WordSize == 1) {
-            return CPDF_String::Create(ReadHexString(), TRUE);
+            return CPDF_String::Create(ReadHexString(), true);
         }
         CPDF_Dictionary* pDict = CPDF_Dictionary::Create();
         while (1) {
@@ -621,7 +621,7 @@ CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOO
                 return NULL;
             }
             CFX_ByteString key = PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
-            CPDF_Object* pObj = ReadNextObject(TRUE);
+            CPDF_Object* pObj = ReadNextObject(true);
             if (pObj == NULL) {
                 if (pDict) {
                     pDict->Release();
@@ -642,7 +642,7 @@ CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOO
         }
         CPDF_Array* pArray = CPDF_Array::Create();
         while (1) {
-            CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, TRUE);
+            CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, true);
             if (pObj == NULL) {
                 if (m_WordSize == 0 || m_WordBuffer[0] == ']') {
                     return pArray;
@@ -657,22 +657,22 @@ CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOO
     }
     if (m_WordSize == 4) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_TRUE) {
-            return CPDF_Boolean::Create(TRUE);
+            return CPDF_Boolean::Create(true);
         }
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_NULL) {
             return CPDF_Null::Create();
         }
     } else if (m_WordSize == 5) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_FALS && m_WordBuffer[4] == 'e') {
-            return CPDF_Boolean::Create(FALSE);
+            return CPDF_Boolean::Create(false);
         }
     }
     return NULL;
 }
-void CPDF_StreamParser::GetNextWord(FX_BOOL& bIsNumber)
+void CPDF_StreamParser::GetNextWord(bool& bIsNumber)
 {
     m_WordSize = 0;
-    bIsNumber = TRUE;
+    bIsNumber = true;
     if (m_Size <= m_Pos) {
         return;
     }
@@ -701,7 +701,7 @@ void CPDF_StreamParser::GetNextWord(FX_BOOL& bIsNumber)
         type = PDF_CharType[ch];
     }
     if (type == 'D') {
-        bIsNumber = FALSE;
+        bIsNumber = false;
         m_WordBuffer[m_WordSize++] = ch;
         if (ch == '/') {
             while (1) {
@@ -746,7 +746,7 @@ void CPDF_StreamParser::GetNextWord(FX_BOOL& bIsNumber)
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (type != 'N') {
-            bIsNumber = FALSE;
+            bIsNumber = false;
         }
         if (m_Size <= m_Pos) {
             return;
@@ -862,7 +862,7 @@ CFX_ByteString CPDF_StreamParser::ReadHexString()
     }
     int ch = m_pBuf[m_Pos++];
     CFX_ByteTextBuf buf;
-    FX_BOOL bFirst = TRUE;
+    bool bFirst = true;
     int code = 0;
     while (1) {
         if (ch == '>') {
@@ -947,7 +947,7 @@ void CPDF_ContentParser::Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions)
         return;
     }
     m_pObjects = pPage;
-    m_bForm = FALSE;
+    m_bForm = false;
     if (pOptions) {
         m_Options = *pOptions;
     }
@@ -962,7 +962,7 @@ void CPDF_ContentParser::Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions)
     if (pContent->GetType() == PDFOBJ_STREAM) {
         m_nStreams = 0;
         m_pSingleStream = new CPDF_StreamAcc;
-        m_pSingleStream->LoadAllData((CPDF_Stream*)pContent, FALSE);
+        m_pSingleStream->LoadAllData((CPDF_Stream*)pContent, false);
     } else if (pContent->GetType() == PDFOBJ_ARRAY) {
         CPDF_Array* pArray = (CPDF_Array*)pContent;
         m_nStreams = pArray->GetCount();
@@ -981,7 +981,7 @@ void CPDF_ContentParser::Start(CPDF_Form* pForm, CPDF_AllStates* pGraphicStates,
 {
     m_pType3Char = pType3Char;
     m_pObjects = pForm;
-    m_bForm = TRUE;
+    m_bForm = true;
     CFX_AffineMatrix form_matrix = pForm->m_pFormDict->GetMatrix(FX_BSTRC("Matrix"));
     if (pGraphicStates) {
         form_matrix.Concat(pGraphicStates->m_CTM);
@@ -1011,7 +1011,7 @@ void CPDF_ContentParser::Start(CPDF_Form* pForm, CPDF_AllStates* pGraphicStates,
     m_pParser->GetCurStates()->m_CTM = form_matrix;
     m_pParser->GetCurStates()->m_ParentMatrix = form_matrix;
     if (ClipPath.NotNull()) {
-        m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, TRUE);
+        m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, true);
     }
     if (pForm->m_Transparency & PDFTRANS_GROUP) {
         CPDF_GeneralStateData* pData = m_pParser->GetCurStates()->m_GeneralState.GetModify();
@@ -1023,9 +1023,9 @@ void CPDF_ContentParser::Start(CPDF_Form* pForm, CPDF_AllStates* pGraphicStates,
     m_nStreams = 0;
     m_pSingleStream = new CPDF_StreamAcc;
     if (pForm->m_pDocument) {
-        m_pSingleStream->LoadAllData(pForm->m_pFormStream, FALSE);
+        m_pSingleStream->LoadAllData(pForm->m_pFormStream, false);
     } else {
-        m_pSingleStream->LoadAllData(pForm->m_pFormStream, FALSE);
+        m_pSingleStream->LoadAllData(pForm->m_pFormStream, false);
     }
     m_pData = (uint8_t*)m_pSingleStream->GetData();
     m_Size = m_pSingleStream->GetSize();
@@ -1070,7 +1070,7 @@ void CPDF_ContentParser::Continue(IFX_Pause* pPause)
                 CPDF_Array* pContent = m_pObjects->m_pFormDict->GetArray(FX_BSTRC("Contents"));
                 m_pStreamArray[m_CurrentOffset] = new CPDF_StreamAcc;
                 CPDF_Stream* pStreamObj = (CPDF_Stream*)(pContent ? pContent->GetElementValue(m_CurrentOffset) : NULL);
-                m_pStreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, FALSE);
+                m_pStreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, false);
                 m_CurrentOffset ++;
             }
         }
diff --git a/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp b/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
index 48b3a40495..8292d2d90e 100644
--- a/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
+++ b/core/src/fpdfapi/fpdf_page/fpdf_page_pattern.cpp
@@ -8,7 +8,7 @@
 #include "pageint.h"
 
 CPDF_Pattern::CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix) :
-    m_pPatternObj(NULL), m_PatternType(PATTERN_TILING), m_pDocument(NULL), m_bForceClear(FALSE)
+    m_pPatternObj(NULL), m_PatternType(PATTERN_TILING), m_pDocument(NULL), m_bForceClear(false)
 {
     if (pParentMatrix) {
         m_ParentMatrix = *pParentMatrix;
@@ -37,28 +37,28 @@ CPDF_TilingPattern::~CPDF_TilingPattern()
     delete m_pForm;
     m_pForm = NULL;
 }
-FX_BOOL CPDF_TilingPattern::Load()
+bool CPDF_TilingPattern::Load()
 {
     if (m_pForm != NULL) {
-        return TRUE;
+        return true;
     }
     CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
     if (pDict == NULL) {
-        return FALSE;
+        return false;
     }
     m_bColored = pDict->GetInteger(FX_BSTRC("PaintType")) == 1;
     m_XStep = (FX_FLOAT)FXSYS_fabs(pDict->GetNumber(FX_BSTRC("XStep")));
     m_YStep = (FX_FLOAT)FXSYS_fabs(pDict->GetNumber(FX_BSTRC("YStep")));
     if (m_pPatternObj->GetType() != PDFOBJ_STREAM) {
-        return FALSE;
+        return false;
     }
     CPDF_Stream* pStream = (CPDF_Stream*)m_pPatternObj;
     m_pForm = new CPDF_Form(m_pDocument, NULL, pStream);
     m_pForm->ParseContent(NULL, &m_ParentMatrix, NULL, NULL);
     m_BBox = pDict->GetRect(FX_BSTRC("BBox"));
-    return TRUE;
+    return true;
 }
-CPDF_ShadingPattern::CPDF_ShadingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* parentMatrix) : CPDF_Pattern(parentMatrix)
+CPDF_ShadingPattern::CPDF_ShadingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* parentMatrix) : CPDF_Pattern(parentMatrix)
 {
     m_PatternType = PATTERN_SHADING;
     m_pPatternObj = bShading ? NULL : pPatternObj;
@@ -102,14 +102,14 @@ void CPDF_ShadingPattern::Clear()
     m_pCountedCS = NULL;
     m_nFuncs = 0;
 }
-FX_BOOL CPDF_ShadingPattern::Load()
+bool CPDF_ShadingPattern::Load()
 {
     if (m_ShadingType != 0) {
-        return TRUE;
+        return true;
     }
     CPDF_Dictionary* pShadingDict = m_pShadingObj ? m_pShadingObj->GetDict() : NULL;
     if (pShadingDict == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_nFuncs) {
         for (int i = 0; i < m_nFuncs; i ++)
@@ -133,7 +133,7 @@ FX_BOOL CPDF_ShadingPattern::Load()
     }
     CPDF_Object* pCSObj = pShadingDict->GetElementValue(FX_BSTRC("ColorSpace"));
     if (pCSObj == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
     m_pCS = pDocPageData->GetColorSpace(pCSObj, NULL);
@@ -141,14 +141,14 @@ FX_BOOL CPDF_ShadingPattern::Load()
         m_pCountedCS = pDocPageData->FindColorSpacePtr(m_pCS->GetArray());
     }
     m_ShadingType = pShadingDict->GetInteger(FX_BSTRC("ShadingType"));
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_ShadingPattern::Reload()
+bool CPDF_ShadingPattern::Reload()
 {
     Clear();
     return Load();
 }
-FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS)
+bool CPDF_MeshStream::Load(CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS)
 {
     m_Stream.LoadAllData(pShadingStream);
     m_BitStream.Init(m_Stream.GetData(), m_Stream.GetSize());
@@ -160,21 +160,21 @@ FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream, CPDF_Function** pFunc
     m_nCompBits = pDict->GetInteger(FX_BSTRC("BitsPerComponent"));
     m_nFlagBits = pDict->GetInteger(FX_BSTRC("BitsPerFlag"));
     if (!m_nCoordBits || !m_nCompBits) {
-        return FALSE;
+        return false;
     }
     int nComps = pCS->CountComponents();
     if (nComps > 8) {
-        return FALSE;
+        return false;
     }
     m_nComps = nFuncs ? 1 : nComps;
     if (((int)m_nComps < 0) || m_nComps > 8) {
-        return FALSE;
+        return false;
     }
     m_CoordMax = m_nCoordBits == 32 ? -1 : (1 << m_nCoordBits) - 1;
     m_CompMax = (1 << m_nCompBits) - 1;
     CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
     if (pDecode == NULL || pDecode->GetCount() != 4 + m_nComps * 2) {
-        return FALSE;
+        return false;
     }
     m_xmin = pDecode->GetNumber(0);
     m_xmax = pDecode->GetNumber(1);
@@ -184,7 +184,7 @@ FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream, CPDF_Function** pFunc
         m_ColorMin[i] = pDecode->GetNumber(i * 2 + 4);
         m_ColorMax[i] = pDecode->GetNumber(i * 2 + 5);
     }
-    return TRUE;
+    return true;
 }
 FX_DWORD CPDF_MeshStream::GetFlag()
 {
@@ -231,18 +231,18 @@ FX_DWORD CPDF_MeshStream::GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* p
     m_BitStream.ByteAlign();
     return flag;
 }
-FX_BOOL CPDF_MeshStream::GetVertexRow(CPDF_MeshVertex* vertex, int count, CFX_AffineMatrix* pObject2Bitmap)
+bool CPDF_MeshStream::GetVertexRow(CPDF_MeshVertex* vertex, int count, CFX_AffineMatrix* pObject2Bitmap)
 {
     for (int i = 0; i < count; i ++) {
         if (m_BitStream.IsEOF()) {
-            return FALSE;
+            return false;
         }
         GetCoords(vertex[i].x, vertex[i].y);
         pObject2Bitmap->Transform(vertex[i].x, vertex[i].y);
         GetColor(vertex[i].r, vertex[i].g, vertex[i].b);
         m_BitStream.ByteAlign();
     }
-    return TRUE;
+    return true;
 }
 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream, int type, const CFX_AffineMatrix* pMatrix,
                               CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS)
@@ -255,8 +255,8 @@ CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream, int type, const CFX_AffineMa
         return CFX_FloatRect(0, 0, 0, 0);
     }
     CFX_FloatRect rect;
-    FX_BOOL bStarted = FALSE;
-    FX_BOOL bGouraud = type == 4 || type == 5;
+    bool bStarted = false;
+    bool bGouraud = type == 4 || type == 5;
     int full_point_count = type == 7 ? 16 : (type == 6 ? 12 : 1);
     int full_color_count = (type == 6 || type == 7) ? 4 : 1;
     while (!stream.m_BitStream.IsEOF()) {
@@ -276,7 +276,7 @@ CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream, int type, const CFX_AffineMa
                 rect.UpdateRect(x, y);
             } else {
                 rect.InitRect(x, y);
-                bStarted = TRUE;
+                bStarted = true;
             }
         }
         stream.m_BitStream.SkipBits(stream.m_nComps * stream.m_nCompBits * color_count);
diff --git a/core/src/fpdfapi/fpdf_page/pageint.h b/core/src/fpdfapi/fpdf_page/pageint.h
index cf1fe47c0d..8fe2555416 100644
--- a/core/src/fpdfapi/fpdf_page/pageint.h
+++ b/core/src/fpdfapi/fpdf_page/pageint.h
@@ -21,7 +21,7 @@ public:
     CPDF_StreamParser(const uint8_t* pData, FX_DWORD dwSize);
     ~CPDF_StreamParser();
 
-    CPDF_Stream*		ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, FX_BOOL bDecode);
+    CPDF_Stream*		ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, bool bDecode);
     typedef enum { EndOfData, Number, Keyword, Name, Others } SyntaxType;
 
     SyntaxType			ParseNextElement();
@@ -48,10 +48,10 @@ public:
         m_Pos = pos;
     }
 
-    CPDF_Object*		ReadNextObject(FX_BOOL bAllowNestedArray = FALSE, FX_BOOL bInArray = FALSE);
+    CPDF_Object*		ReadNextObject(bool bAllowNestedArray = false, bool bInArray = false);
     void				SkipPathObject();
 protected:
-    void				GetNextWord(FX_BOOL& bIsNumber);
+    void				GetNextWord(bool& bIsNumber);
     CFX_ByteString		ReadString();
     CFX_ByteString		ReadHexString();
     const uint8_t*		m_pBuf;
@@ -105,7 +105,7 @@ typedef struct {
     int			m_Type;
     union {
         struct {
-            FX_BOOL		m_bInteger;
+            bool		m_bInteger;
             union {
                 int		m_Integer;
                 FX_FLOAT m_Float;
@@ -137,10 +137,10 @@ public:
         int level);
     ~CPDF_StreamContentParser();
 
-    FX_BOOL ShouldAbort() const { return m_bAbort; }
+    bool ShouldAbort() const { return m_bAbort; }
     CPDF_PageObjects* GetObjectList() const { return m_pObjectList; }
     CPDF_AllStates* GetCurStates() const { return m_pCurStates.get(); }
-    FX_BOOL IsColored() const { return m_bColored; }
+    bool IsColored() const { return m_bColored; }
     const FX_FLOAT* GetType3Data() const { return m_Type3Data; }
 
     void				AddNumberParam(const FX_CHAR* str, int len);
@@ -156,7 +156,7 @@ public:
     {
         return (int32_t)(GetNumber(index));
     }
-    FX_BOOL				OnOperator(const FX_CHAR* op);
+    bool				OnOperator(const FX_CHAR* op);
     void				BigCaseCaller(int index);
     FX_DWORD			GetParsePos()
     {
@@ -171,16 +171,16 @@ public:
     void				ParsePathObject();
     void				AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag);
     void				AddPathRect(FX_FLOAT x, FX_FLOAT y, FX_FLOAT w, FX_FLOAT h);
-    void				AddPathObject(int FillType, FX_BOOL bStroke);
-    CPDF_ImageObject*	AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, FX_BOOL bInline);
+    void				AddPathObject(int FillType, bool bStroke);
+    CPDF_ImageObject*	AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, bool bInline);
     void				AddDuplicateImage();
     void				AddForm(CPDF_Stream*);
-    void				SetGraphicStates(CPDF_PageObject* pObj, FX_BOOL bColor, FX_BOOL bText, FX_BOOL bGraph);
+    void				SetGraphicStates(CPDF_PageObject* pObj, bool bColor, bool bText, bool bGraph);
     void				SaveStates(CPDF_AllStates*);
     void				RestoreStates(CPDF_AllStates*);
     CPDF_Font*			FindFont(const CFX_ByteString& name);
     CPDF_ColorSpace*	FindColorSpace(const CFX_ByteString& name);
-    CPDF_Pattern*		FindPattern(const CFX_ByteString& name, FX_BOOL bShading);
+    CPDF_Pattern*		FindPattern(const CFX_ByteString& name, bool bShading);
     CPDF_Object*		FindResourceObj(const CFX_ByteStringC& type, const CFX_ByteString& name);
 
 protected:
@@ -277,7 +277,7 @@ protected:
     _ContentParam m_ParamBuf1[PARAM_BUF_SIZE];
     FX_DWORD m_ParamStartPos;
     FX_DWORD m_ParamCount;
-    FX_BOOL m_bAbort;
+    bool m_bAbort;
     CPDF_StreamParser* m_pSyntax;
     nonstd::unique_ptr<CPDF_AllStates> m_pCurStates;
     CPDF_ContentMark m_CurContentMark;
@@ -299,11 +299,11 @@ protected:
     CFX_BinaryBuf m_LastImageData;
     CPDF_Dictionary* m_pLastImageDict;
     CPDF_Dictionary* m_pLastCloneImageDict;
-    FX_BOOL m_bReleaseLastDict;
-    FX_BOOL m_bSameLastDict;
-    FX_BOOL m_bColored;
+    bool m_bReleaseLastDict;
+    bool m_bSameLastDict;
+    bool m_bColored;
     FX_FLOAT m_Type3Data[6];
-    FX_BOOL m_bResourceMissing;
+    bool m_bResourceMissing;
     CFX_PtrArray m_StateStack;
 };
 class CPDF_ContentParser
@@ -325,7 +325,7 @@ protected:
     void				Clear();
     ParseStatus			m_Status;
     CPDF_PageObjects*	m_pObjects;
-    FX_BOOL				m_bForm;
+    bool				m_bForm;
     CPDF_ParseOptions	m_Options;
     CPDF_Type3Char*		m_pType3Char;
     int					m_InternalStage;
@@ -357,22 +357,22 @@ class CPDF_DocPageData
     explicit CPDF_DocPageData(CPDF_Document *pPDFDoc);
     ~CPDF_DocPageData();
 
-    void                        Clear(FX_BOOL bRelease = FALSE);
-    CPDF_Font*                  GetFont(CPDF_Dictionary* pFontDict, FX_BOOL findOnly);
+    void                        Clear(bool bRelease = false);
+    CPDF_Font*                  GetFont(CPDF_Dictionary* pFontDict, bool findOnly);
     CPDF_Font*                  GetStandardFont(const CFX_ByteStringC& fontName, CPDF_FontEncoding* pEncoding);
     void                        ReleaseFont(CPDF_Dictionary* pFontDict);
     CPDF_ColorSpace*            GetColorSpace(CPDF_Object* pCSObj, CPDF_Dictionary* pResources);
     CPDF_ColorSpace*            GetCopiedColorSpace(CPDF_Object* pCSObj);
     void                        ReleaseColorSpace(CPDF_Object* pColorSpace);
-    CPDF_Pattern*               GetPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix);
+    CPDF_Pattern*               GetPattern(CPDF_Object* pPatternObj, bool bShading, const CFX_AffineMatrix* matrix);
     void                        ReleasePattern(CPDF_Object* pPatternObj);
     CPDF_Image*                 GetImage(CPDF_Object* pImageStream);
     void                        ReleaseImage(CPDF_Object* pImageStream);
     CPDF_IccProfile*            GetIccProfile(CPDF_Stream* pIccProfileStream);
     void                        ReleaseIccProfile(CPDF_IccProfile* pIccProfile);
     CPDF_StreamAcc*             GetFontFileStreamAcc(CPDF_Stream* pFontStream);
-    void                        ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, FX_BOOL bForce = FALSE);
-    FX_BOOL                     IsForceClear() const {return m_bForceClear;}
+    void                        ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, bool bForce = false);
+    bool                     IsForceClear() const {return m_bForceClear;}
     CPDF_CountedColorSpace*     FindColorSpacePtr(CPDF_Object* pCSObj) const;
     CPDF_CountedPattern*        FindPatternPtr(CPDF_Object* pPatternObj) const;
 
@@ -391,7 +391,7 @@ class CPDF_DocPageData
 
     CPDF_Document* const m_pPDFDoc;
     CFX_MapByteStringToPtr m_HashProfileMap;
-    FX_BOOL m_bForceClear;
+    bool m_bForceClear;
 
     CPDF_ColorSpaceMap m_ColorSpaceMap;
     CPDF_FontFileMap m_FontFileMap;
@@ -406,7 +406,7 @@ class CPDF_Function
 public:
     static CPDF_Function*	Load(CPDF_Object* pFuncObj);
     virtual ~CPDF_Function();
-    FX_BOOL		Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const;
+    bool		Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const;
     int			CountInputs()
     {
         return m_nInputs;
@@ -420,9 +420,9 @@ protected:
     int			m_nInputs, m_nOutputs;
     FX_FLOAT*	m_pDomains;
     FX_FLOAT*	m_pRanges;
-    FX_BOOL		Init(CPDF_Object* pObj);
-    virtual FX_BOOL	v_Init(CPDF_Object* pObj) = 0;
-    virtual FX_BOOL	v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const = 0;
+    bool		Init(CPDF_Object* pObj);
+    virtual bool	v_Init(CPDF_Object* pObj) = 0;
+    virtual bool	v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const = 0;
 };
 class CPDF_IccProfile
 {
@@ -430,7 +430,7 @@ public:
     CPDF_IccProfile(const uint8_t* pData, FX_DWORD dwSize);
     ~CPDF_IccProfile();
     int32_t GetComponents() const { return m_nSrcComponents; }
-    FX_BOOL					m_bsRGB;
+    bool					m_bsRGB;
     void*				m_pTransform;
 private:
     int32_t                m_nSrcComponents;
@@ -441,20 +441,20 @@ class CPDF_DeviceCS : public CPDF_ColorSpace
 public:
     CPDF_DeviceCS(CPDF_Document* pDoc, int family);
 
-    FX_BOOL GetRGB(FX_FLOAT* pBuf,
+    bool GetRGB(FX_FLOAT* pBuf,
                    FX_FLOAT& R,
                    FX_FLOAT& G,
                    FX_FLOAT& B) const override;
-    FX_BOOL SetRGB(FX_FLOAT* pBuf,
+    bool SetRGB(FX_FLOAT* pBuf,
                    FX_FLOAT R,
                    FX_FLOAT G,
                    FX_FLOAT B) const override;
-    FX_BOOL v_GetCMYK(FX_FLOAT* pBuf,
+    bool v_GetCMYK(FX_FLOAT* pBuf,
                       FX_FLOAT& c,
                       FX_FLOAT& m,
                       FX_FLOAT& y,
                       FX_FLOAT& k) const override;
-    FX_BOOL v_SetCMYK(FX_FLOAT* pBuf,
+    bool v_SetCMYK(FX_FLOAT* pBuf,
                       FX_FLOAT c,
                       FX_FLOAT m,
                       FX_FLOAT y,
@@ -464,7 +464,7 @@ public:
                             int pixels,
                             int image_width,
                             int image_height,
-                            FX_BOOL bTransMask = FALSE) const override;
+                            bool bTransMask = false) const override;
 };
 
 class CPDF_PatternCS : public CPDF_ColorSpace
@@ -476,8 +476,8 @@ public:
           m_pCountedBaseCS(nullptr) {
     }
     ~CPDF_PatternCS() override;
-    FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
-    FX_BOOL GetRGB(FX_FLOAT* pBuf,
+    bool v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) override;
+    bool GetRGB(FX_FLOAT* pBuf,
                    FX_FLOAT& R,
                    FX_FLOAT& G,
                    FX_FLOAT& B) const override;
diff --git a/core/src/fpdfapi/fpdf_parser/filters_int.h b/core/src/fpdfapi/fpdf_parser/filters_int.h
index 2ec54fb1f5..c27ade8a70 100644
--- a/core/src/fpdfapi/fpdf_parser/filters_int.h
+++ b/core/src/fpdfapi/fpdf_parser/filters_int.h
@@ -31,11 +31,11 @@ public:
 class CPDF_LzwFilter : public CFX_DataFilter
 {
 public:
-    CPDF_LzwFilter(FX_BOOL bEarlyChange);
+    CPDF_LzwFilter(bool bEarlyChange);
     virtual ~CPDF_LzwFilter() {}
     virtual	void	v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
     virtual void	v_FilterFinish(CFX_BinaryBuf& dest_buf) {}
-    FX_BOOL			m_bEarlyChange;
+    bool			m_bEarlyChange;
     FX_DWORD		m_CodeArray[5021];
     FX_DWORD		m_nCodes;
     FX_DWORD		m_CodeLen;
@@ -54,7 +54,7 @@ public:
     virtual ~CPDF_PredictorFilter();
     virtual	void	v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
     virtual void	v_FilterFinish(CFX_BinaryBuf& dest_buf) {}
-    FX_BOOL			m_bTiff;
+    bool			m_bTiff;
     FX_DWORD		m_Pitch, m_Bpp;
     uint8_t*		m_pRefLine;
     uint8_t*		m_pCurLine;
@@ -102,14 +102,14 @@ public:
     CFX_BinaryBuf	m_InputBuf;
     uint8_t*		m_pScanline;
     int				m_Pitch, m_Height, m_Width, m_nComps, m_iLine;
-    FX_BOOL			m_bGotHeader;
+    bool			m_bGotHeader;
 };
 class CPDF_FaxFilter : public CFX_DataFilter
 {
 public:
     CPDF_FaxFilter();
     virtual ~CPDF_FaxFilter();
-    FX_BOOL			Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns);
+    bool			Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns);
     virtual	void	v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
     virtual void	v_FilterFinish(CFX_BinaryBuf& dest_buf);
     int				m_Encoding, m_bEndOfLine, m_bByteAlign, m_bBlack;
@@ -118,9 +118,9 @@ public:
 	uint8_t*		m_pRefBuf;
     CFX_BinaryBuf	m_InputBuf;
     int				m_InputBitPos;
-    void			ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, FX_BOOL bFinish,
+    void			ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, bool bFinish,
                                 CFX_BinaryBuf& dest_buf);
-    FX_BOOL			ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos);
+    bool			ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos);
 };
 
 #endif  // CORE_SRC_FPDFAPI_FPDF_PARSER_FILTERS_INT_H_
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
index 47c08fb4a3..e60888a292 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_decode.cpp
@@ -91,7 +91,7 @@ FX_DWORD _HexDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_bu
         }
     dest_buf = FX_Alloc( uint8_t, i / 2 + 1);
     dest_size = 0;
-    FX_BOOL bFirstDigit = TRUE;
+    bool bFirstDigit = true;
     for (i = 0; i < src_size; i ++) {
         uint8_t ch = src_buf[i];
         if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') {
@@ -186,9 +186,9 @@ ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(const uint8_t* src_buf, FX_DWOR
         const CPDF_Dictionary* pParams)
 {
     int K = 0;
-    FX_BOOL EndOfLine = FALSE;
-    FX_BOOL ByteAlign = FALSE;
-    FX_BOOL BlackIs1 = FALSE;
+    bool EndOfLine = false;
+    bool ByteAlign = false;
+    bool BlackIs1 = false;
     int Columns = 1728;
     int Rows = 0;
     if (pParams) {
@@ -208,25 +208,25 @@ ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(const uint8_t* src_buf, FX_DWOR
     return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(src_buf, src_size, width, height,
             K, EndOfLine, ByteAlign, BlackIs1, Columns, Rows);
 }
-static FX_BOOL CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns)
+static bool CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns)
 {
     if (Columns < 0) {
-        return FALSE;
+        return false;
     }
     int check = Columns;
     if (Colors < 0 || (check > 0 && Colors > INT_MAX / check)) {
-        return FALSE;
+        return false;
     }
     check *= Colors;
     if (BitsPerComponent < 0 ||
             (check > 0 && BitsPerComponent > INT_MAX / check)) {
-        return FALSE;
+        return false;
     }
     check *= BitsPerComponent;
     if (check > INT_MAX - 7) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, const CPDF_Dictionary* pParams)
@@ -245,11 +245,11 @@ ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(const uint8_t* src_buf, FX_DW
     return CPDF_ModuleMgr::Get()->GetFlateModule()->CreateDecoder(src_buf, src_size, width, height,
             nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
 }
-FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
+FX_DWORD FPDFAPI_FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
                                   FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     int predictor = 0;
-    FX_BOOL bEarlyChange = TRUE;
+    bool bEarlyChange = true;
     int Colors = 0, BitsPerComponent = 0, Columns = 0;
     if (pParams) {
         predictor = ((CPDF_Dictionary*)pParams)->GetInteger(FX_BSTRC("Predictor"));
@@ -265,14 +265,14 @@ FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD
             bEarlyChange, predictor, Colors, BitsPerComponent, Columns, estimated_size,
             dest_buf, dest_size);
 }
-FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
+bool PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
                        uint8_t*& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
-                       CPDF_Dictionary*& pImageParms, FX_DWORD last_estimated_size, FX_BOOL bImageAcc)
+                       CPDF_Dictionary*& pImageParms, FX_DWORD last_estimated_size, bool bImageAcc)
 
 {
     CPDF_Object* pDecoder = pDict ? pDict->GetElementValue(FX_BSTRC("Filter")) : NULL;
     if (pDecoder == NULL || (pDecoder->GetType() != PDFOBJ_ARRAY && pDecoder->GetType() != PDFOBJ_NAME)) {
-        return FALSE;
+        return false;
     }
     CPDF_Object* pParams = pDict ? pDict->GetElementValue(FX_BSTRC("DecodeParms")) : NULL;
     CFX_ByteStringArray DecoderList;
@@ -310,11 +310,11 @@ FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dic
                 dest_buf = (uint8_t*)last_buf;
                 dest_size = last_size;
                 pImageParms = pParam;
-                return TRUE;
+                return true;
             }
-            offset = FPDFAPI_FlateOrLZWDecode(FALSE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
+            offset = FPDFAPI_FlateOrLZWDecode(false, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
         } else if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {
-            offset = FPDFAPI_FlateOrLZWDecode(TRUE, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
+            offset = FPDFAPI_FlateOrLZWDecode(true, last_buf, last_size, pParam, estimated_size, new_buf, new_size);
         } else if (decoder == FX_BSTRC("ASCII85Decode") || decoder == FX_BSTRC("A85")) {
             offset = _A85Decode(last_buf, last_size, new_buf, new_size);
         } else if (decoder == FX_BSTRC("ASCIIHexDecode") || decoder == FX_BSTRC("AHx")) {
@@ -325,7 +325,7 @@ FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dic
                 dest_buf = (uint8_t*)last_buf;
                 dest_size = last_size;
                 pImageParms = pParam;
-                return TRUE;
+                return true;
             }
             offset = RunLengthDecode(last_buf, last_size, new_buf, new_size);
         } else {
@@ -340,13 +340,13 @@ FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dic
             pImageParms = pParam;
             dest_buf = (uint8_t*)last_buf;
             dest_size = last_size;
-            return TRUE;
+            return true;
         }
         if (last_buf != src_buf) {
             FX_Free(last_buf);
         }
         if (offset == -1) {
-            return FALSE;
+            return false;
         }
         last_buf = new_buf;
         last_size = new_size;
@@ -355,7 +355,7 @@ FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dic
     pImageParms = NULL;
     dest_buf = last_buf;
     dest_size = last_size;
-    return TRUE;
+    return true;
 }
 extern const FX_WORD PDFDocEncoding[256] = {
     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009,
@@ -389,7 +389,7 @@ CFX_WideString PDF_DecodeText(const uint8_t* src_data, FX_DWORD src_len, CFX_Cha
 {
     CFX_WideString result;
     if (src_len >= 2 && ((src_data[0] == 0xfe && src_data[1] == 0xff) || (src_data[0] == 0xff && src_data[1] == 0xfe))) {
-        FX_BOOL bBE = src_data[0] == 0xfe;
+        bool bBE = src_data[0] == 0xfe;
         FX_DWORD max_chars = (src_len - 2) / 2;
         if (!max_chars) {
             return result;
@@ -472,7 +472,7 @@ CFX_ByteString PDF_EncodeText(const FX_WCHAR* pString, int len, CFX_CharMap* pCh
     result.ReleaseBuffer(encLen);
     return result;
 }
-CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex)
+CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, bool bHex)
 {
     CFX_ByteTextBuf result;
     int srclen = src.GetLength();
@@ -521,7 +521,7 @@ FX_DWORD FlateDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_b
 {
     CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
     if (pEncoders) {
-        return pEncoders->GetFlateModule()->FlateOrLZWDecode(FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
+        return pEncoders->GetFlateModule()->FlateOrLZWDecode(false, src_buf, src_size, false, 0, 0, 0, 0, 0, dest_buf, dest_size);
     }
     return 0;
 }
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_document.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_document.cpp
index c0f45c5379..0ea692ed4d 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_document.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_document.cpp
@@ -12,7 +12,7 @@ CPDF_Document::CPDF_Document(CPDF_Parser* pParser) : CPDF_IndirectObjects(pParse
     ASSERT(pParser != NULL);
     m_pRootDict = NULL;
     m_pInfoDict = NULL;
-    m_bLinearized = FALSE;
+    m_bLinearized = false;
     m_dwFirstPageNo = 0;
     m_dwFirstPageObjNum = 0;
     m_pDocPage = CPDF_ModuleMgr::Get()->GetPageModule()->CreateDocData(this);
@@ -58,7 +58,7 @@ void CPDF_Document::LoadDoc()
 }
 void CPDF_Document::LoadAsynDoc(CPDF_Dictionary *pLinearized)
 {
-    m_bLinearized = TRUE;
+    m_bLinearized = true;
     m_LastObjNum = m_pParser->GetLastObjNum();
     CPDF_Object* indirectObj = GetIndirectObject(m_pParser->GetRootObjNum());
     m_pRootDict = indirectObj ? indirectObj->GetDict() : NULL;
@@ -228,7 +228,7 @@ int CPDF_Document::GetPageIndex(FX_DWORD objnum)
 {
     FX_DWORD nPages = m_PageList.GetSize();
     FX_DWORD skip_count = 0;
-    FX_BOOL bSkipped = FALSE;
+    bool bSkipped = false;
     for (FX_DWORD i = 0; i < nPages; i ++) {
         FX_DWORD objnum1 = m_PageList.GetAt(i);
         if (objnum1 == objnum) {
@@ -236,7 +236,7 @@ int CPDF_Document::GetPageIndex(FX_DWORD objnum)
         }
         if (!bSkipped && objnum1 == 0) {
             skip_count = i;
-            bSkipped = TRUE;
+            bSkipped = true;
         }
     }
     CPDF_Dictionary* pRoot = GetRoot();
@@ -297,7 +297,7 @@ int CPDF_Document::_GetPageCount() const
     }
     return _CountPages(pPages, 0);
 }
-FX_BOOL CPDF_Document::IsContentUsedElsewhere(FX_DWORD objnum, CPDF_Dictionary* pThisPageDict)
+bool CPDF_Document::IsContentUsedElsewhere(FX_DWORD objnum, CPDF_Dictionary* pThisPageDict)
 {
     for (int i = 0; i < m_PageList.GetSize(); i ++) {
         CPDF_Dictionary* pPageDict = GetPage(i);
@@ -316,42 +316,42 @@ FX_BOOL CPDF_Document::IsContentUsedElsewhere(FX_DWORD objnum, CPDF_Dictionary*
                     continue;
                 }
                 if (((CPDF_Reference*) pRef)->GetRefObjNum() == objnum) {
-                    return TRUE;
+                    return true;
                 }
             }
         } else if (pContents->GetObjNum() == objnum) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_DWORD CPDF_Document::GetUserPermissions(FX_BOOL bCheckRevision) const
+FX_DWORD CPDF_Document::GetUserPermissions(bool bCheckRevision) const
 {
     if (m_pParser == NULL) {
         return (FX_DWORD) - 1;
     }
     return m_pParser->GetPermissions(bCheckRevision);
 }
-FX_BOOL CPDF_Document::IsOwner() const
+bool CPDF_Document::IsOwner() const
 {
     if (m_pParser == NULL) {
-        return TRUE;
+        return true;
     }
     return m_pParser->IsOwner();
 }
-FX_BOOL CPDF_Document::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm) const
+bool CPDF_Document::IsFormStream(FX_DWORD objnum, bool& bForm) const
 {
     {
         CPDF_Object* pObj;
         if (m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, (void*&)pObj)) {
             bForm = pObj->GetType() == PDFOBJ_STREAM &&
                     ((CPDF_Stream*)pObj)->GetDict()->GetString(FX_BSTRC("Subtype")) == FX_BSTRC("Form");
-            return TRUE;
+            return true;
         }
     }
     if (m_pParser == NULL) {
-        bForm = FALSE;
-        return TRUE;
+        bForm = false;
+        return true;
     }
     return m_pParser->IsFormStream(objnum, bForm);
 }
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
index 9f356a4748..ff6f0e12bd 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp
@@ -14,7 +14,7 @@ const uint8_t defpasscode[32] = {
     0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a
 };
 void CalcEncryptKey(CPDF_Dictionary* pEncrypt, const uint8_t* password, FX_DWORD pass_size,
-                    uint8_t* key, int keylen, FX_BOOL bIgnoreMeta, CPDF_Array* pIdArray)
+                    uint8_t* key, int keylen, bool bIgnoreMeta, CPDF_Array* pIdArray)
 {
     int revision = pEncrypt->GetInteger(FX_BSTRC("R"));
     uint8_t passcode[32];
@@ -57,7 +57,7 @@ CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler()
 typedef struct _PDF_CRYPTOITEM  {
     int32_t	m_Cipher;
     int32_t	m_KeyLen;
-    FX_BOOL		m_bChecked;
+    bool		m_bChecked;
     CPDF_StandardCryptoHandler*	m_pCryptoHandler;
 } PDF_CRYPTOITEM;
 CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()
@@ -66,7 +66,7 @@ CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()
     m_Revision = 0;
     m_pParser = NULL;
     m_pEncryptDict = NULL;
-    m_bOwner = FALSE;
+    m_bOwner = false;
     m_Permissions = 0;
     m_Cipher = FXCIPHER_NONE;
     m_KeyLen = 0;
@@ -74,36 +74,36 @@ CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()
 CPDF_StandardSecurityHandler::~CPDF_StandardSecurityHandler()
 {
 }
-FX_BOOL CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict)
+bool CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict)
 {
     m_pParser = pParser;
     if (!LoadDict(pEncryptDict)) {
-        return FALSE;
+        return false;
     }
     if (m_Cipher == FXCIPHER_NONE) {
-        return TRUE;
+        return true;
     }
     return CheckSecurity(m_KeyLen);
 }
-FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len)
+bool CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len)
 {
     CFX_ByteString password = m_pParser->GetPassword();
-    if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey, key_len)) {
+    if (CheckPassword(password, password.GetLength(), true, m_EncryptKey, key_len)) {
         if (password.IsEmpty()) {
-            if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len)) {
-                return FALSE;
+            if (!CheckPassword(password, password.GetLength(), false, m_EncryptKey, key_len)) {
+                return false;
             }
         }
-        m_bOwner = TRUE;
-        return TRUE;
+        m_bOwner = true;
+        return true;
     }
-    return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len);
+    return CheckPassword(password, password.GetLength(), false, m_EncryptKey, key_len);
 }
 FX_DWORD CPDF_StandardSecurityHandler::GetPermissions()
 {
     return m_Permissions;
 }
-static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStringC& name, int& cipher, int& keylen)
+static bool _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStringC& name, int& cipher, int& keylen)
 {
     int Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
     cipher = FXCIPHER_RC4;
@@ -111,14 +111,14 @@ static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStrin
     if (Version >= 4) {
         CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDict(FX_BSTRC("CF"));
         if (pCryptFilters == NULL) {
-            return FALSE;
+            return false;
         }
         if (name == FX_BSTRC("Identity")) {
             cipher = FXCIPHER_NONE;
         } else {
             CPDF_Dictionary* pDefFilter = pCryptFilters->GetDict(name);
             if (pDefFilter == NULL) {
-                return FALSE;
+                return false;
             }
             int nKeyBits = 0;
             if (Version == 4) {
@@ -142,14 +142,14 @@ static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStrin
         keylen = Version > 1 ? pEncryptDict->GetInteger(FX_BSTRC("Length"), 40) / 8 : 5;
     }
     if (keylen > 32 || keylen < 0) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)
+bool CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)
 {
     m_pEncryptDict = pEncryptDict;
-    m_bOwner = FALSE;
+    m_bOwner = false;
     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
@@ -159,17 +159,17 @@ FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)
     CFX_ByteString stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
     CFX_ByteString strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
     if (stmf_name != strf_name) {
-        return FALSE;
+        return false;
     }
     if (!_LoadCryptInfo(pEncryptDict, strf_name, m_Cipher, m_KeyLen)) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len)
+bool CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len)
 {
     m_pEncryptDict = pEncryptDict;
-    m_bOwner = FALSE;
+    m_bOwner = false;
     m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));
     m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));
     m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);
@@ -178,23 +178,23 @@ FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX
         stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));
         strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));
         if (stmf_name != strf_name) {
-            return FALSE;
+            return false;
         }
     }
     if (!_LoadCryptInfo(pEncryptDict, strf_name, cipher, key_len)) {
-        return FALSE;
+        return false;
     }
     m_Cipher = cipher;
     m_KeyLen = key_len;
-    return TRUE;
-    return TRUE;
+    return true;
+    return true;
 }
-FX_BOOL CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen)
+bool CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen)
 {
     cipher = m_Cipher;
     buffer = m_EncryptKey;
     keylen = m_KeyLen;
-    return TRUE;
+    return true;
 }
 #define FX_GET_32WORD(n,b,i)								\
     {														\
@@ -252,7 +252,7 @@ void Revision6_Hash(const uint8_t* password, FX_DWORD size, const uint8_t* salt,
                 content.AppendBlock(vector, 48);
             }
         }
-        CRYPT_AESSetKey(aes, 16, key, 16, TRUE);
+        CRYPT_AESSetKey(aes, 16, key, 16, true);
         CRYPT_AESSetIV(aes, iv);
         CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen);
         int iHash = 0;
@@ -288,16 +288,16 @@ void Revision6_Hash(const uint8_t* password, FX_DWORD size, const uint8_t* salt,
         FXSYS_memcpy(hash, input, 32);
     }
 }
-FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* password, FX_DWORD size,
-        FX_BOOL bOwner, uint8_t* key)
+bool CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* password, FX_DWORD size,
+        bool bOwner, uint8_t* key)
 {
     CFX_ByteString okey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("O")) : CFX_ByteString();
     if (okey.GetLength() < 48) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
     if (ukey.GetLength() < 48) {
-        return FALSE;
+        return false;
     }
     const uint8_t* pkey = bOwner ? (const uint8_t*)okey : (const uint8_t*)ukey;
     uint8_t sha[128];
@@ -314,10 +314,10 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo
         CRYPT_SHA256Finish(sha, digest);
     }
     if (FXSYS_memcmp(digest, pkey, 32) != 0) {
-        return FALSE;
+        return false;
     }
     if (key == NULL) {
-        return TRUE;
+        return true;
     }
     if (m_Revision >= 6) {
         Revision6_Hash(password, size, (const uint8_t*)pkey + 40, (bOwner ? (const uint8_t*)ukey : NULL), digest);
@@ -332,19 +332,19 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo
     }
     CFX_ByteString ekey = m_pEncryptDict ? m_pEncryptDict->GetString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE")) : CFX_ByteString();
     if (ekey.GetLength() < 32) {
-        return FALSE;
+        return false;
     }
     uint8_t* aes = FX_Alloc(uint8_t, 2048);
-    CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
+    CRYPT_AESSetKey(aes, 16, digest, 32, false);
     uint8_t iv[16];
     FXSYS_memset(iv, 0, 16);
     CRYPT_AESSetIV(aes, iv);
     CRYPT_AESDecrypt(aes, key, ekey, 32);
-    CRYPT_AESSetKey(aes, 16, key, 32, FALSE);
+    CRYPT_AESSetKey(aes, 16, key, 32, false);
     CRYPT_AESSetIV(aes, iv);
     CFX_ByteString perms = m_pEncryptDict->GetString(FX_BSTRC("Perms"));
     if (perms.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     uint8_t perms_buf[16];
     FXSYS_memset(perms_buf, 0, sizeof(perms_buf));
@@ -357,21 +357,21 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo
     CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
     FX_Free(aes);
     if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {
-        return FALSE;
+        return false;
     }
     if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {
-        return FALSE;
+        return false;
     }
     if ((buf[8] == 'T' && !IsMetadataEncrypted()) || (buf[8] == 'F' && IsMetadataEncrypted())) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD pass_size, FX_BOOL bOwner, uint8_t* key)
+int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD pass_size, bool bOwner, uint8_t* key)
 {
     return CheckPassword(password, pass_size, bOwner, key, m_KeyLen);
 }
-int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, uint8_t* key, int32_t key_len)
+int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD size, bool bOwner, uint8_t* key, int32_t key_len)
 {
     if (m_Revision >= 5) {
         return AES256_CheckPassword(password, size, bOwner, key);
@@ -383,16 +383,16 @@ int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWOR
     if (bOwner) {
         return CheckOwnerPassword(password, size, key, key_len);
     }
-    return CheckUserPassword(password, size, FALSE, key, key_len) || CheckUserPassword(password, size, TRUE, key, key_len);
+    return CheckUserPassword(password, size, false, key, key_len) || CheckUserPassword(password, size, true, key, key_len);
 }
-FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password, FX_DWORD pass_size,
-        FX_BOOL bIgnoreEncryptMeta, uint8_t* key, int32_t key_len)
+bool CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password, FX_DWORD pass_size,
+        bool bIgnoreEncryptMeta, uint8_t* key, int32_t key_len)
 {
     CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len, bIgnoreEncryptMeta,
                    m_pParser->GetIDArray());
     CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
     if (ukey.GetLength() < 16) {
-        return FALSE;
+        return false;
     }
     uint8_t ukeybuf[32];
     if (m_Revision == 2) {
@@ -425,9 +425,9 @@ FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password,
         return FXSYS_memcmp(test, ukeybuf, 16) == 0;
     }
     if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size)
 {
@@ -480,18 +480,18 @@ CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(const uint8_t* owne
     }
     return CFX_ByteString(okeybuf, len);
 }
-FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(const uint8_t* password, FX_DWORD pass_size,
+bool CPDF_StandardSecurityHandler::CheckOwnerPassword(const uint8_t* password, FX_DWORD pass_size,
         uint8_t* key, int32_t key_len)
 {
     CFX_ByteString user_pass = GetUserPassword(password, pass_size, key_len);
-    if (CheckUserPassword(user_pass, user_pass.GetLength(), FALSE, key, key_len)) {
-        return TRUE;
+    if (CheckUserPassword(user_pass, user_pass.GetLength(), false, key, key_len)) {
+        return true;
     }
-    return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key, key_len);
+    return CheckUserPassword(user_pass, user_pass.GetLength(), true, key, key_len);
 }
-FX_BOOL CPDF_StandardSecurityHandler::IsMetadataEncrypted()
+bool CPDF_StandardSecurityHandler::IsMetadataEncrypted()
 {
-    return m_pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE);
+    return m_pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), true);
 }
 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler()
 {
@@ -499,7 +499,7 @@ CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler()
 }
 void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
         const uint8_t* user_pass, FX_DWORD user_size,
-        const uint8_t* owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type)
+        const uint8_t* owner_pass, FX_DWORD owner_size, bool bDefault, FX_DWORD type)
 {
     int cipher = 0, key_len = 0;
     if (!LoadDict(pEncryptDict, type, cipher, key_len)) {
@@ -517,10 +517,10 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_
         CRYPT_SHA256Update(sha, m_EncryptKey, 32);
         CRYPT_SHA256Update(sha, (uint8_t*)"there", 5);
         CRYPT_SHA256Finish(sha, m_EncryptKey);
-        AES256_SetPassword(pEncryptDict, user_pass, user_size, FALSE, m_EncryptKey);
+        AES256_SetPassword(pEncryptDict, user_pass, user_size, false, m_EncryptKey);
         if (bDefault) {
-            AES256_SetPassword(pEncryptDict, owner_pass, owner_size, TRUE, m_EncryptKey);
-            AES256_SetPerms(pEncryptDict, m_Permissions, pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE), m_EncryptKey);
+            AES256_SetPassword(pEncryptDict, owner_pass, owner_size, true, m_EncryptKey);
+            AES256_SetPerms(pEncryptDict, m_Permissions, pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), true), m_EncryptKey);
         }
         return;
     }
@@ -554,7 +554,7 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_
         }
         pEncryptDict->SetAtString(FX_BSTRC("O"), CFX_ByteString(passcode, 32));
     }
-    CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey, key_len, FALSE, pIdArray);
+    CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey, key_len, false, pIdArray);
     if (m_Revision < 3) {
         uint8_t tempbuf[32];
         FXSYS_memcpy(tempbuf, defpasscode, 32);
@@ -586,13 +586,13 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_
         const uint8_t* user_pass, FX_DWORD user_size,
         const uint8_t* owner_pass, FX_DWORD owner_size, FX_DWORD type)
 {
-    OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size, TRUE, type);
+    OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size, true, type);
 }
 void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray, const uint8_t* user_pass, FX_DWORD user_size, FX_DWORD type)
 {
-    OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);
+    OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, false, type);
 }
-void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, const uint8_t* key)
+void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, const uint8_t* password, FX_DWORD size, bool bOwner, const uint8_t* key)
 {
     uint8_t sha[128];
     CRYPT_SHA1Start(sha);
@@ -627,7 +627,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptD
         CRYPT_SHA256Finish(sha, digest1);
     }
     uint8_t* aes = FX_Alloc(uint8_t, 2048);
-    CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);
+    CRYPT_AESSetKey(aes, 16, digest1, 32, true);
     uint8_t iv[16];
     FXSYS_memset(iv, 0, 16);
     CRYPT_AESSetIV(aes, iv);
@@ -636,7 +636,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptD
     pEncryptDict->SetAtString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE"), CFX_ByteString(digest1, 32));
 }
 void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permissions,
-        FX_BOOL bEncryptMetadata, const uint8_t* key)
+        bool bEncryptMetadata, const uint8_t* key)
 {
     uint8_t buf[16];
     buf[0] = (uint8_t)permissions;
@@ -652,7 +652,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict
     buf[10] = 'd';
     buf[11] = 'b';
     uint8_t* aes = FX_Alloc(uint8_t, 2048);
-    CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
+    CRYPT_AESSetKey(aes, 16, key, 32, true);
     uint8_t iv[16], buf1[16];
     FXSYS_memset(iv, 0, 16);
     CRYPT_AESSetIV(aes, iv);
@@ -660,7 +660,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict
     FX_Free(aes);
     pEncryptDict->SetAtString(FX_BSTRC("Perms"), CFX_ByteString(buf1, 16));
 }
-void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,
+void CPDF_StandardCryptoHandler::CryptBlock(bool bEncrypt, FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,
         uint8_t* dest_buf, FX_DWORD& dest_size)
 {
     if (m_Cipher == FXCIPHER_NONE) {
@@ -720,18 +720,18 @@ void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, F
 }
 typedef struct _AESCryptContext {
     uint8_t		m_Context[2048];
-    FX_BOOL		m_bIV;
+    bool		m_bIV;
     uint8_t		m_Block[16];
     FX_DWORD	m_BlockOffset;
 } AESCryptContext;
-void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt)
+void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, bool bEncrypt)
 {
     if (m_Cipher == FXCIPHER_NONE) {
         return this;
     }
     if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {
         AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
-        pContext->m_bIV = TRUE;
+        pContext->m_bIV = true;
         pContext->m_BlockOffset = 0;
         CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);
         if (bEncrypt) {
@@ -757,7 +757,7 @@ void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, F
     }
     if (m_Cipher == FXCIPHER_AES) {
         AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
-        pContext->m_bIV = TRUE;
+        pContext->m_bIV = true;
         pContext->m_BlockOffset = 0;
         CRYPT_AESSetKey(pContext->m_Context, 16, realkey, 16, bEncrypt);
         if (bEncrypt) {
@@ -772,25 +772,25 @@ void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, F
     CRYPT_ArcFourSetup(pContext, realkey, realkeylen);
     return pContext;
 }
-FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)
+bool CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, bool bEncrypt)
 {
     if (!context) {
-        return FALSE;
+        return false;
     }
     if (m_Cipher == FXCIPHER_NONE) {
         dest_buf.AppendBlock(src_buf, src_size);
-        return TRUE;
+        return true;
     }
     if (m_Cipher == FXCIPHER_RC4) {
         int old_size = dest_buf.GetSize();
         dest_buf.AppendBlock(src_buf, src_size);
         CRYPT_ArcFourCrypt(context, dest_buf.GetBuffer() + old_size, src_size);
-        return TRUE;
+        return true;
     }
     AESCryptContext* pContext = (AESCryptContext*)context;
     if (pContext->m_bIV && bEncrypt) {
         dest_buf.AppendBlock(pContext->m_Block, 16);
-        pContext->m_bIV = FALSE;
+        pContext->m_bIV = false;
     }
     FX_DWORD src_off = 0;
     FX_DWORD src_left = src_size;
@@ -806,7 +806,7 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* sr
         if (pContext->m_BlockOffset == 16) {
             if (!bEncrypt && pContext->m_bIV) {
                 CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
-                pContext->m_bIV = FALSE;
+                pContext->m_bIV = false;
                 pContext->m_BlockOffset = 0;
             } else if (src_off < src_size) {
                 uint8_t block_buf[16];
@@ -823,19 +823,19 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* sr
             break;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)
+bool CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& dest_buf, bool bEncrypt)
 {
     if (!context) {
-        return FALSE;
+        return false;
     }
     if (m_Cipher == FXCIPHER_NONE) {
-        return TRUE;
+        return true;
     }
     if (m_Cipher == FXCIPHER_RC4) {
         FX_Free(context);
-        return TRUE;
+        return true;
     }
     AESCryptContext* pContext = (AESCryptContext*)context;
     if (bEncrypt) {
@@ -856,24 +856,24 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& de
         }
     }
     FX_Free(pContext);
-    return TRUE;
+    return true;
 }
 void* CPDF_StandardCryptoHandler::DecryptStart(FX_DWORD objnum, FX_DWORD gennum)
 {
-    return CryptStart(objnum, gennum, FALSE);
+    return CryptStart(objnum, gennum, false);
 }
 FX_DWORD CPDF_StandardCryptoHandler::DecryptGetSize(FX_DWORD src_size)
 {
     return m_Cipher == FXCIPHER_AES ? src_size - 16 : src_size;
 }
-FX_BOOL CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler)
+bool CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler)
 {
     const uint8_t* key;
     if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) {
-        return FALSE;
+        return false;
     }
     if (m_KeyLen > 32 || m_KeyLen < 0) {
-        return FALSE;
+        return false;
     }
     if (m_Cipher != FXCIPHER_NONE) {
         FXSYS_memcpy(m_EncryptKey, key, m_KeyLen);
@@ -881,9 +881,9 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_Sec
     if (m_Cipher == FXCIPHER_AES) {
         m_pAESContext = FX_Alloc(uint8_t, 2048);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int keylen)
+bool CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int keylen)
 {
     if (cipher == FXCIPHER_AES) {
         switch(keylen) {
@@ -892,15 +892,15 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int key
             case 32:
                 break;
             default:
-                return FALSE;
+                return false;
         }
     } else if (cipher == FXCIPHER_AES2) {
         if (keylen != 32) {
-            return FALSE;
+            return false;
         }
     } else if (cipher == FXCIPHER_RC4) {
         if (keylen < 5 || keylen > 16) {
-            return FALSE;
+            return false;
         }
     } else {
         if (keylen > 32) {
@@ -913,16 +913,16 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int key
     if (m_Cipher == FXCIPHER_AES) {
         m_pAESContext = FX_Alloc(uint8_t, 2048);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_StandardCryptoHandler::DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size,
+bool CPDF_StandardCryptoHandler::DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size,
         CFX_BinaryBuf& dest_buf)
 {
-    return CryptStream(context, src_buf, src_size, dest_buf, FALSE);
+    return CryptStream(context, src_buf, src_size, dest_buf, false);
 }
-FX_BOOL CPDF_StandardCryptoHandler::DecryptFinish(void* context, CFX_BinaryBuf& dest_buf)
+bool CPDF_StandardCryptoHandler::DecryptFinish(void* context, CFX_BinaryBuf& dest_buf)
 {
-    return CryptFinish(context, dest_buf, FALSE);
+    return CryptFinish(context, dest_buf, false);
 }
 FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size)
 {
@@ -931,11 +931,11 @@ FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum, FX_DWORD ve
     }
     return src_size;
 }
-FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,
+bool CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,
         uint8_t* dest_buf, FX_DWORD& dest_size)
 {
-    CryptBlock(TRUE, objnum, gennum, src_buf, src_size, dest_buf, dest_size);
-    return TRUE;
+    CryptBlock(true, objnum, gennum, src_buf, src_size, dest_buf, dest_size);
+    return true;
 }
 void CPDF_CryptoHandler::Decrypt(FX_DWORD objnum, FX_DWORD gennum, CFX_ByteString& str)
 {
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_fdf.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_fdf.cpp
index 1958fab280..ffce46bdd2 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_fdf.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_fdf.cpp
@@ -9,7 +9,7 @@ CFDF_Document::CFDF_Document() : CPDF_IndirectObjects(NULL)
 {
     m_pRootDict = NULL;
     m_pFile = NULL;
-    m_bOwnFile = FALSE;
+    m_bOwnFile = false;
 }
 CFDF_Document::~CFDF_Document()
 {
@@ -26,7 +26,7 @@ CFDF_Document* CFDF_Document::CreateNewDoc()
     pDoc->m_pRootDict->SetAt(FX_BSTRC("FDF"), pFDFDict);
     return pDoc;
 }
-CFDF_Document* CFDF_Document::ParseFile(IFX_FileRead *pFile, FX_BOOL bOwnFile)
+CFDF_Document* CFDF_Document::ParseFile(IFX_FileRead *pFile, bool bOwnFile)
 {
   if (!pFile) {
     return NULL;
@@ -41,16 +41,16 @@ CFDF_Document* CFDF_Document::ParseFile(IFX_FileRead *pFile, FX_BOOL bOwnFile)
 }
 CFDF_Document* CFDF_Document::ParseMemory(const uint8_t* pData, FX_DWORD size)
 {
-    return CFDF_Document::ParseFile(FX_CreateMemoryStream((uint8_t*)pData, size), TRUE);
+    return CFDF_Document::ParseFile(FX_CreateMemoryStream((uint8_t*)pData, size), true);
 }
-void CFDF_Document::ParseStream(IFX_FileRead *pFile, FX_BOOL bOwnFile)
+void CFDF_Document::ParseStream(IFX_FileRead *pFile, bool bOwnFile)
 {
     m_pFile = pFile;
     m_bOwnFile = bOwnFile;
     CPDF_SyntaxParser parser;
     parser.InitParser(m_pFile, 0);
     while (1) {
-        FX_BOOL bNumber;
+        bool bNumber;
         CFX_ByteString word = parser.GetNextWord(bNumber);
         if (bNumber) {
             FX_DWORD objnum = FXSYS_atoi(word);
@@ -85,10 +85,10 @@ void CFDF_Document::ParseStream(IFX_FileRead *pFile, FX_BOOL bOwnFile)
         }
     }
 }
-FX_BOOL CFDF_Document::WriteBuf(CFX_ByteTextBuf& buf) const
+bool CFDF_Document::WriteBuf(CFX_ByteTextBuf& buf) const
 {
     if (m_pRootDict == NULL) {
-        return FALSE;
+        return false;
     }
     buf << FX_BSTRC("%FDF-1.2\r\n");
     FX_POSITION pos = m_IndirectObjs.GetStartPosition();
@@ -99,7 +99,7 @@ FX_BOOL CFDF_Document::WriteBuf(CFX_ByteTextBuf& buf) const
         buf << (FX_DWORD)objnum << FX_BSTRC(" 0 obj\r\n") << pObj << FX_BSTRC("\r\nendobj\r\n\r\n");
     }
     buf << FX_BSTRC("trailer\r\n<</Root ") << m_pRootDict->GetObjNum() << FX_BSTRC(" 0 R>>\r\n%%EOF\r\n");
-    return TRUE;
+    return true;
 }
 CFX_WideString CFDF_Document::GetWin32Path() const
 {
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
index fed4546fab..f81aa73cb3 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.cpp
@@ -25,7 +25,7 @@ static void my_free_func(void* opaque, void* address)
 
 CFX_DataFilter::CFX_DataFilter()
 {
-    m_bEOF = FALSE;
+    m_bEOF = false;
     m_pDestFilter = NULL;
     m_SrcPos = 0;
 }
@@ -68,14 +68,14 @@ void CFX_DataFilter::FilterFinish(CFX_BinaryBuf& dest_buf)
     } else {
         v_FilterFinish(dest_buf);
     }
-    m_bEOF = TRUE;
+    m_bEOF = true;
 }
 void CFX_DataFilter::ReportEOF(FX_DWORD left_input)
 {
     if (m_bEOF) {
         return;
     }
-    m_bEOF = TRUE;
+    m_bEOF = true;
     m_SrcPos -= left_input;
 }
 CFX_DataFilter* FPDF_CreateFilter(const CFX_ByteStringC& name, const CPDF_Dictionary* pParam, int width, int height)
@@ -113,9 +113,9 @@ CFX_DataFilter* FPDF_CreateFilter(const CFX_ByteStringC& name, const CPDF_Dictio
             return new CPDF_RunLenFilter;
         case FXBSTR_ID('C', 'C', 'I', 'T'): {
                 int Encoding = 0;
-                int bEndOfLine = FALSE;
-                int bByteAlign = FALSE;
-                int bBlack = FALSE;
+                int bEndOfLine = false;
+                int bByteAlign = false;
+                int bBlack = false;
                 int nRows = 0;
                 int nColumns = 1728;
                 if (pParam) {
@@ -178,7 +178,7 @@ CFX_DataFilter* _FPDF_CreateFilterFromDict(CPDF_Dictionary* pDict)
     }
     return pFirstFilter;
 }
-CPDF_StreamFilter* CPDF_Stream::GetStreamFilter(FX_BOOL bRaw) const
+CPDF_StreamFilter* CPDF_Stream::GetStreamFilter(bool bRaw) const
 {
     CFX_DataFilter* pFirstFilter = NULL;
     if (m_pCryptoHandler) {
@@ -294,7 +294,7 @@ void CPDF_DecryptFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, C
 }
 void CPDF_DecryptFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
 {
-    m_bEOF = TRUE;
+    m_bEOF = true;
     if (m_pContext == NULL) {
         return;
     }
@@ -330,7 +330,7 @@ void CPDF_FlateFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX
         }
     }
 }
-CPDF_LzwFilter::CPDF_LzwFilter(FX_BOOL bEarlyChange)
+CPDF_LzwFilter::CPDF_LzwFilter(bool bEarlyChange)
 {
     m_bEarlyChange = bEarlyChange ? 1 : 0;
     m_CodeLen = 9;
@@ -697,7 +697,7 @@ void CPDF_RunLenFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CF
 CPDF_JpegFilter::CPDF_JpegFilter()
 {
     m_pContext = NULL;
-    m_bGotHeader = FALSE;
+    m_bGotHeader = false;
     m_pScanline = NULL;
     m_iLine = 0;
 }
@@ -742,7 +742,7 @@ void CPDF_JpegFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_
             return;
         }
         CPDF_ModuleMgr::Get()->GetJpegModule()->StartScanline(m_pContext, 1);
-        m_bGotHeader = TRUE;
+        m_bGotHeader = true;
         m_Pitch = m_Width * m_nComps;
     }
     if (m_pScanline == NULL) {
@@ -765,9 +765,9 @@ void CPDF_JpegFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_
 CPDF_FaxFilter::CPDF_FaxFilter()
 {
     m_Encoding = 0;
-    m_bEndOfLine = FALSE;
-    m_bByteAlign = FALSE;
-    m_bBlack = FALSE;
+    m_bEndOfLine = false;
+    m_bByteAlign = false;
+    m_bBlack = false;
     m_nRows = 0;
     m_nColumns = 0;
     m_Pitch = 0;
@@ -785,7 +785,7 @@ CPDF_FaxFilter::~CPDF_FaxFilter()
         FX_Free(m_pRefBuf);
     }
 }
-FX_BOOL CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns)
+bool CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns)
 {
     m_Encoding = Encoding;
     m_bEndOfLine = bEndOfLine;
@@ -800,7 +800,7 @@ FX_BOOL CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign,
     FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
     m_iRow = 0;
     m_InputBitPos = 0;
-    return TRUE;
+    return true;
 }
 void CPDF_FaxFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
 {
@@ -821,19 +821,19 @@ void CPDF_FaxFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_B
         fax_src_size = src_size;
         bitpos = 0;
     }
-    ProcessData(fax_src_buf, fax_src_size, bitpos, FALSE, dest_buf);
+    ProcessData(fax_src_buf, fax_src_size, bitpos, false, dest_buf);
     int left_bits = fax_src_size * 8 - bitpos;
     m_InputBuf.AppendBlock(fax_src_buf + bitpos / 8, (left_bits + 7) / 8);
     m_InputBitPos = bitpos % 8;
 }
 void CPDF_FaxFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
 {
-    ProcessData(m_InputBuf.GetBuffer(), m_InputBuf.GetSize(), m_InputBitPos, TRUE, dest_buf);
+    ProcessData(m_InputBuf.GetBuffer(), m_InputBuf.GetSize(), m_InputBitPos, true, dest_buf);
 }
-FX_BOOL _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos);
-FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns);
-FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns);
-void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, FX_BOOL bFinish,
+bool _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos);
+bool _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns);
+bool _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns);
+void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, bool bFinish,
                                  CFX_BinaryBuf& dest_buf)
 {
     int bitsize = src_size * 8;
@@ -863,21 +863,21 @@ void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int&
         }
     }
 }
-FX_BOOL CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos)
+bool CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos)
 {
     if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL ret;
+    bool ret;
     if (m_Encoding < 0) {
         ret = _FaxG4GetRow(src_buf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_nColumns);
     } else if (m_Encoding == 0) {
         ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
     } else {
         if (bitpos == bitsize) {
-            return FALSE;
+            return false;
         }
-        FX_BOOL bNext1D = src_buf[bitpos / 8] & (1 << (7 - bitpos % 8));
+        bool bNext1D = src_buf[bitpos / 8] & (1 << (7 - bitpos % 8));
         bitpos ++;
         if (bNext1D) {
             ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
@@ -886,14 +886,14 @@ FX_BOOL CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpo
         }
     }
     if (!ret) {
-        return FALSE;
+        return false;
     }
     if (m_bEndOfLine)
         if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
-            return FALSE;
+            return false;
         }
     if (m_bByteAlign) {
         bitpos = (bitpos + 7) / 8 * 8;
     }
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
index c7d1dece25..96e6807102 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.cpp
@@ -180,7 +180,7 @@ void CPDF_Object::SetString(const CFX_ByteString& str)
             ((CPDF_Name*)this)->m_Name = str;
             return;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
 }
 int CPDF_Object::GetDirectType() const
 {
@@ -190,13 +190,13 @@ int CPDF_Object::GetDirectType() const
     CPDF_Reference* pRef = (CPDF_Reference*)this;
     return pRef->m_pObjList->GetIndirectType(pRef->m_RefObjNum);
 }
-FX_BOOL CPDF_Object::IsIdentical(CPDF_Object* pOther) const
+bool CPDF_Object::IsIdentical(CPDF_Object* pOther) const
 {
     if (this == pOther) {
-        return TRUE;
+        return true;
     }
     if (pOther == NULL) {
-        return FALSE;
+        return false;
     }
     if (pOther->m_Type != m_Type) {
         if (m_Type == PDFOBJ_REFERENCE && GetDirect()) {
@@ -205,7 +205,7 @@ FX_BOOL CPDF_Object::IsIdentical(CPDF_Object* pOther) const
         if (pOther->m_Type == PDFOBJ_REFERENCE) {
             return IsIdentical(pOther->GetDirect());
         }
-        return FALSE;
+        return false;
     }
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
@@ -221,13 +221,13 @@ FX_BOOL CPDF_Object::IsIdentical(CPDF_Object* pOther) const
         case PDFOBJ_DICTIONARY:
             return (((CPDF_Dictionary*)this)->Identical((CPDF_Dictionary*)pOther));
         case PDFOBJ_NULL:
-            return TRUE;
+            return true;
         case PDFOBJ_STREAM:
             return (((CPDF_Stream*)this)->Identical((CPDF_Stream*)pOther));
         case PDFOBJ_REFERENCE:
             return (((CPDF_Reference*)this)->Identical((CPDF_Reference*)pOther));
     }
-    return FALSE;
+    return false;
 }
 CPDF_Object* CPDF_Object::GetDirect() const
 {
@@ -240,12 +240,12 @@ CPDF_Object* CPDF_Object::GetDirect() const
     }
     return pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
 }
-CPDF_Object* CPDF_Object::Clone(FX_BOOL bDirect) const
+CPDF_Object* CPDF_Object::Clone(bool bDirect) const
 {
     CFX_MapPtrToPtr visited;
     return CloneInternal(bDirect, &visited);
 }
-CPDF_Object* CPDF_Object::CloneInternal(FX_BOOL bDirect, CFX_MapPtrToPtr* visited) const
+CPDF_Object* CPDF_Object::CloneInternal(bool bDirect, CFX_MapPtrToPtr* visited) const
 {
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
@@ -284,7 +284,7 @@ CPDF_Object* CPDF_Object::CloneInternal(FX_BOOL bDirect, CFX_MapPtrToPtr* visite
         case PDFOBJ_STREAM: {
                 CPDF_Stream* pThis = (CPDF_Stream*)this;
                 CPDF_StreamAcc acc;
-                acc.LoadAllData(pThis, TRUE);
+                acc.LoadAllData(pThis, true);
                 FX_DWORD streamSize = acc.GetSize();
                 CPDF_Dictionary* pDict = pThis->GetDict();
                 if (pDict)
@@ -299,7 +299,7 @@ CPDF_Object* CPDF_Object::CloneInternal(FX_BOOL bDirect, CFX_MapPtrToPtr* visite
                     if (!pRef->GetDirect())
                         return nullptr;
 
-                    return pRef->GetDirect()->CloneInternal(TRUE, visited);
+                    return pRef->GetDirect()->CloneInternal(true, visited);
                 }
                 return new CPDF_Reference(pRef->m_pObjList, obj_num);
             }
@@ -320,7 +320,7 @@ CFX_WideString CPDF_Object::GetUnicodeText(CFX_CharMap* pCharMap) const
     }
     if (m_Type == PDFOBJ_STREAM) {
         CPDF_StreamAcc stream;
-        stream.LoadAllData((CPDF_Stream*)this, FALSE);
+        stream.LoadAllData((CPDF_Stream*)this, false);
         CFX_WideString result = PDF_DecodeText(stream.GetData(), stream.GetSize(), pCharMap);
         return result;
     }
@@ -335,19 +335,19 @@ void CPDF_Object::SetUnicodeText(const FX_WCHAR* pUnicodes, int len)
         ((CPDF_String*)this)->m_String = PDF_EncodeText(pUnicodes, len);
     } else if (m_Type == PDFOBJ_STREAM) {
         CFX_ByteString result = PDF_EncodeText(pUnicodes, len);
-        ((CPDF_Stream*)this)->SetData((uint8_t*)result.c_str(), result.GetLength(), FALSE, FALSE);
+        ((CPDF_Stream*)this)->SetData((uint8_t*)result.c_str(), result.GetLength(), false, false);
     }
 }
 
 CPDF_Number::CPDF_Number(int value)
-    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(TRUE), m_Integer(value) {
+    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(true), m_Integer(value) {
 }
 
 CPDF_Number::CPDF_Number(FX_FLOAT value)
-    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(FALSE), m_Float(value) {
+    : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(false), m_Float(value) {
 }
 
-CPDF_Number::CPDF_Number(FX_BOOL bInteger, void* pData)
+CPDF_Number::CPDF_Number(bool bInteger, void* pData)
     : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(bInteger), m_Integer(*(int*)pData) {
 }
 
@@ -359,7 +359,7 @@ void CPDF_Number::SetString(const CFX_ByteStringC& str)
 {
     FX_atonum(str, m_bInteger, &m_Integer);
 }
-FX_BOOL CPDF_Number::Identical(CPDF_Number* pOther) const
+bool CPDF_Number::Identical(CPDF_Number* pOther) const
 {
     return m_bInteger == pOther->m_bInteger && m_Integer == pOther->m_Integer;
 }
@@ -369,10 +369,10 @@ CFX_ByteString CPDF_Number::GetString() const
 }
 void CPDF_Number::SetNumber(FX_FLOAT value)
 {
-    m_bInteger = FALSE;
+    m_bInteger = false;
     m_Float = value;
 }
-CPDF_String::CPDF_String(const CFX_WideString& str) : CPDF_Object(PDFOBJ_STRING), m_bHex(FALSE) {
+CPDF_String::CPDF_String(const CFX_WideString& str) : CPDF_Object(PDFOBJ_STRING), m_bHex(false) {
     m_String = PDF_EncodeText(str);
 }
 CPDF_Array::~CPDF_Array()
@@ -553,16 +553,16 @@ void CPDF_Array::AddReference(CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
     ASSERT(m_Type == PDFOBJ_ARRAY);
     Add(new CPDF_Reference(pDoc, objnum));
 }
-FX_BOOL CPDF_Array::Identical(CPDF_Array* pOther) const
+bool CPDF_Array::Identical(CPDF_Array* pOther) const
 {
     if (m_Objects.GetSize() != pOther->m_Objects.GetSize()) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < m_Objects.GetSize(); i ++)
         if (!((CPDF_Object*)m_Objects[i])->IsIdentical((CPDF_Object*)pOther->m_Objects[i])) {
-            return FALSE;
+            return false;
         }
-    return TRUE;
+    return true;
 }
 CPDF_Dictionary::~CPDF_Dictionary()
 {
@@ -677,7 +677,7 @@ FX_FLOAT CPDF_Dictionary::GetNumber(const CFX_ByteStringC& key) const
     }
     return 0;
 }
-FX_BOOL CPDF_Dictionary::GetBoolean(const CFX_ByteStringC& key, FX_BOOL bDefault) const
+bool CPDF_Dictionary::GetBoolean(const CFX_ByteStringC& key, bool bDefault) const
 {
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
@@ -734,7 +734,7 @@ CFX_AffineMatrix CPDF_Dictionary::GetMatrix(const CFX_ByteStringC& key) const
     }
     return matrix;
 }
-FX_BOOL CPDF_Dictionary::KeyExist(const CFX_ByteStringC& key) const
+bool CPDF_Dictionary::KeyExist(const CFX_ByteStringC& key) const
 {
     void* value;
     return m_Map.Lookup(key, value);
@@ -786,13 +786,13 @@ void CPDF_Dictionary::ReplaceKey(const CFX_ByteStringC& oldkey, const CFX_ByteSt
     m_Map.RemoveKey(oldkey);
     m_Map.SetAt(newkey, p);
 }
-FX_BOOL CPDF_Dictionary::Identical(CPDF_Dictionary* pOther) const
+bool CPDF_Dictionary::Identical(CPDF_Dictionary* pOther) const
 {
     if (pOther == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_Map.GetCount() != pOther->m_Map.GetCount()) {
-        return FALSE;
+        return false;
     }
     FX_POSITION pos = m_Map.GetStartPosition();
     while (pos) {
@@ -800,12 +800,12 @@ FX_BOOL CPDF_Dictionary::Identical(CPDF_Dictionary* pOther) const
         void* value;
         m_Map.GetNextAssoc(pos, key, value);
         if (!value)
-            return FALSE;
+            return false;
         if (!((CPDF_Object*)value)->IsIdentical(pOther->GetElement(key))) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Dictionary::SetAtInteger(const CFX_ByteStringC& key, int i)
 {
@@ -833,7 +833,7 @@ void CPDF_Dictionary::SetAtNumber(const CFX_ByteStringC& key, FX_FLOAT f)
     pNumber->SetNumber(f);
     SetAt(key, pNumber);
 }
-void CPDF_Dictionary::SetAtBoolean(const CFX_ByteStringC& key, FX_BOOL bValue)
+void CPDF_Dictionary::SetAtBoolean(const CFX_ByteStringC& key, bool bValue)
 {
     SetAt(key, new CPDF_Boolean(bValue));
 }
@@ -905,7 +905,7 @@ void CPDF_Stream::InitStream(uint8_t* pData, FX_DWORD size, CPDF_Dictionary* pDi
         m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
     }
 }
-void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, FX_BOOL bCompressed, FX_BOOL bKeepBuf)
+void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, bool bCompressed, bool bKeepBuf)
 {
     if (m_GenNum == (FX_DWORD) - 1) {
         if (m_pDataBuf) {
@@ -933,7 +933,7 @@ void CPDF_Stream::SetData(const uint8_t* pData, FX_DWORD size, FX_BOOL bCompress
         m_pDict->RemoveAt(FX_BSTRC("DecodeParms"));
     }
 }
-FX_BOOL CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size) const
+bool CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size) const
 {
     if ((m_GenNum != (FX_DWORD) - 1) && m_pFile) {
         return m_pFile->ReadBlock(buf, m_FileOffset + offset, size);
@@ -941,7 +941,7 @@ FX_BOOL CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size
     if (m_pDataBuf) {
         FXSYS_memcpy(buf, m_pDataBuf + offset, size);
     }
-    return TRUE;
+    return true;
 }
 void CPDF_Stream::InitStream(IFX_FileRead *pFile, CPDF_Dictionary* pDict)
 {
@@ -952,23 +952,23 @@ void CPDF_Stream::InitStream(IFX_FileRead *pFile, CPDF_Dictionary* pDict)
         m_pDict->SetAtInteger(FX_BSTRC("Length"), m_dwSize);
     }
 }
-FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
+bool CPDF_Stream::Identical(CPDF_Stream* pOther) const
 {
     if (!m_pDict)
-        return pOther->m_pDict ? FALSE : TRUE;
+        return pOther->m_pDict ? false : true;
 
     if (!m_pDict->Identical(pOther->m_pDict)) {
-        return FALSE;
+        return false;
     }
     if (m_dwSize != pOther->m_dwSize) {
-        return FALSE;
+        return false;
     }
     if (m_GenNum != (FX_DWORD) - 1 && pOther->m_GenNum != (FX_DWORD) - 1) {
         if (m_pFile == pOther->m_pFile && m_pFile == NULL) {
-            return TRUE;
+            return true;
         }
         if (!m_pFile || !pOther->m_pFile) {
-            return FALSE;
+            return false;
         }
         uint8_t srcBuf[1024];
         uint8_t destBuf[1024];
@@ -976,20 +976,20 @@ FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
         FX_DWORD srcOffset = m_FileOffset;
         FX_DWORD destOffset = pOther->m_FileOffset;
         if (m_pFile == pOther->m_pFile && srcOffset == destOffset) {
-            return TRUE;
+            return true;
         }
         while (size > 0) {
             FX_DWORD actualSize = size > 1024 ? 1024 : size;
             m_pFile->ReadBlock(srcBuf, srcOffset, actualSize);
             pOther->m_pFile->ReadBlock(destBuf, destOffset, actualSize);
             if (FXSYS_memcmp(srcBuf, destBuf, actualSize) != 0) {
-                return FALSE;
+                return false;
             }
             size -= actualSize;
             srcOffset += actualSize;
             destOffset += actualSize;
         }
-        return TRUE;
+        return true;
     }
     if (m_GenNum != (FX_DWORD) - 1 || pOther->m_GenNum != (FX_DWORD) - 1) {
         IFX_FileRead* pFile = NULL;
@@ -1005,7 +1005,7 @@ FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
             offset = m_FileOffset;
         }
         if (NULL == pBuf) {
-            return FALSE;
+            return false;
         }
         uint8_t srcBuf[1024];
         FX_DWORD size = m_dwSize;
@@ -1013,17 +1013,17 @@ FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
             FX_DWORD actualSize = std::min(size, 1024U);
             pFile->ReadBlock(srcBuf, offset, actualSize);
             if (FXSYS_memcmp(srcBuf, pBuf, actualSize) != 0) {
-                return FALSE;
+                return false;
             }
             pBuf += actualSize;
             size -= actualSize;
             offset += actualSize;
         }
-        return TRUE;
+        return true;
     }
     return FXSYS_memcmp(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
 }
-CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
+CPDF_Stream* CPDF_Stream::Clone(bool bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
 {
     CPDF_Dictionary *pCloneDict = (CPDF_Dictionary*)m_pDict->Clone(bDirect);
     IFX_FileStream *pFS = NULL;
@@ -1032,12 +1032,12 @@ CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpf
     }
     if (!pFS) {
         CPDF_StreamAcc acc;
-        acc.LoadAllData(this, TRUE);
+        acc.LoadAllData(this, true);
         FX_DWORD streamSize = acc.GetSize();
         return new CPDF_Stream(acc.DetachData(), streamSize, pCloneDict);
     }
     CPDF_Stream* pObj = new CPDF_Stream(NULL, 0, NULL);
-    CPDF_StreamFilter *pSF = GetStreamFilter(TRUE);
+    CPDF_StreamFilter *pSF = GetStreamFilter(true);
     if (pSF) {
         uint8_t* pBuf = FX_Alloc(uint8_t, 4096);
         FX_DWORD dwRead;
@@ -1054,20 +1054,20 @@ CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpf
     pObj->InitStream((IFX_FileRead*)pFS, pCloneDict);
     return pObj;
 }
-extern FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
+extern bool PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
                               uint8_t*& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
-                              CPDF_Dictionary*& pImageParms, FX_DWORD estimated_size, FX_BOOL bImageAcc);
+                              CPDF_Dictionary*& pImageParms, FX_DWORD estimated_size, bool bImageAcc);
 CPDF_StreamAcc::CPDF_StreamAcc()
 {
-    m_bNewBuf = FALSE;
+    m_bNewBuf = false;
     m_pData = NULL;
     m_dwSize = 0;
     m_pImageParam = NULL;
     m_pStream = NULL;
     m_pSrcData = NULL;
 }
-void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, FX_BOOL bRawAccess, FX_DWORD estimated_size,
-                                 FX_BOOL bImageAcc)
+void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, bool bRawAccess, FX_DWORD estimated_size,
+                                 bool bImageAcc)
 {
     if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) {
         return;
@@ -1111,7 +1111,7 @@ void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, FX_BOOL bRawAccess,
         m_pData = pDecryptedData;
         m_dwSize = dwDecryptedSize;
     } else {
-        FX_BOOL bRet = PDF_DataDecode(pDecryptedData, dwDecryptedSize, m_pStream->GetDict(),
+        bool bRet = PDF_DataDecode(pDecryptedData, dwDecryptedSize, m_pStream->GetDict(),
                                       m_pData, m_dwSize, m_ImageDecoder, m_pImageParam, estimated_size, bImageAcc);
         if (!bRet) {
             m_pData = pDecryptedData;
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
index 854be75ad4..07f6ca783c 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.cpp
@@ -13,19 +13,19 @@
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "../fpdf_page/pageint.h"
 
-FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict)
+bool IsSignatureDict(const CPDF_Dictionary* pDict)
 {
     CPDF_Object* pType = pDict->GetElementValue(FX_BSTRC("Type"));
     if (!pType) {
         pType = pDict->GetElementValue(FX_BSTRC("FT"));
         if (!pType) {
-            return FALSE;
+            return false;
         }
     }
     if (pType->GetString() == FX_BSTRC("Sig")) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 static int _CompareFileSize(const void* p1, const void* p2)
 {
@@ -48,13 +48,13 @@ CPDF_Parser::CPDF_Parser()
     m_pLinearized = NULL;
     m_dwFirstPageNo = 0;
     m_dwXrefStartObjNum = 0;
-    m_bOwnFileRead = TRUE;
+    m_bOwnFileRead = true;
     m_FileVersion = 0;
-    m_bForceUseSecurityHandler = FALSE;
+    m_bForceUseSecurityHandler = false;
 }
 CPDF_Parser::~CPDF_Parser()
 {
-    CloseParser(FALSE);
+    CloseParser(false);
 }
 FX_DWORD CPDF_Parser::GetLastObjNum()
 {
@@ -65,9 +65,9 @@ void CPDF_Parser::SetEncryptDictionary(CPDF_Dictionary* pDict)
 {
     m_pEncryptDict = pDict;
 }
-void CPDF_Parser::CloseParser(FX_BOOL bReParse)
+void CPDF_Parser::CloseParser(bool bReParse)
 {
-    m_bVersionUpdated = FALSE;
+    m_bVersionUpdated = false;
     if (!bReParse) {
         delete m_pDocument;
         m_pDocument = NULL;
@@ -124,7 +124,7 @@ static int32_t GetHeaderOffset(IFX_FileRead* pFile)
     }
     return -1;
 }
-FX_DWORD CPDF_Parser::StartParse(const FX_CHAR* filename, FX_BOOL bReParse)
+FX_DWORD CPDF_Parser::StartParse(const FX_CHAR* filename, bool bReParse)
 {
     IFX_FileRead* pFileAccess = FX_CreateFileRead(filename);
     if (!pFileAccess) {
@@ -132,7 +132,7 @@ FX_DWORD CPDF_Parser::StartParse(const FX_CHAR* filename, FX_BOOL bReParse)
     }
     return StartParse(pFileAccess, bReParse);
 }
-FX_DWORD CPDF_Parser::StartParse(const FX_WCHAR* filename, FX_BOOL bReParse)
+FX_DWORD CPDF_Parser::StartParse(const FX_WCHAR* filename, bool bReParse)
 {
     IFX_FileRead* pFileAccess = FX_CreateFileRead(filename);
     if (!pFileAccess) {
@@ -142,10 +142,10 @@ FX_DWORD CPDF_Parser::StartParse(const FX_WCHAR* filename, FX_BOOL bReParse)
 }
 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
 CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*);
-FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX_BOOL bOwnFileRead)
+FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, bool bReParse, bool bOwnFileRead)
 {
     CloseParser(bReParse);
-    m_bXRefStream = FALSE;
+    m_bXRefStream = false;
     m_LastXRefOffset = 0;
     m_bOwnFileRead = bOwnFileRead;
     int32_t offset = GetHeaderOffset(pFileAccess);
@@ -176,15 +176,15 @@ FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX
     if (!bReParse) {
         m_pDocument = new CPDF_Document(this);
     }
-    FX_BOOL bXRefRebuilt = FALSE;
-    if (m_Syntax.SearchWord(FX_BSTRC("startxref"), TRUE, FALSE, 4096)) {
+    bool bXRefRebuilt = false;
+    if (m_Syntax.SearchWord(FX_BSTRC("startxref"), true, false, 4096)) {
         FX_FILESIZE startxref_offset = m_Syntax.SavePos();
         void* pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             m_SortedOffset.Add(startxref_offset);
         }
         m_Syntax.GetKeyword();
-        FX_BOOL bNumber;
+        bool bNumber;
         CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(bNumber);
         if (!bNumber) {
             return PDFPARSE_ERROR_FORMAT;
@@ -194,14 +194,14 @@ FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX
             if (!RebuildCrossRef()) {
                 return PDFPARSE_ERROR_FORMAT;
             }
-            bXRefRebuilt = TRUE;
+            bXRefRebuilt = true;
             m_LastXRefOffset = 0;
         }
     } else {
         if (!RebuildCrossRef()) {
             return PDFPARSE_ERROR_FORMAT;
         }
-        bXRefRebuilt = TRUE;
+        bXRefRebuilt = true;
     }
     FX_DWORD dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
@@ -340,26 +340,26 @@ static int32_t GetDirectInteger(CPDF_Dictionary* pDict, const CFX_ByteStringC& k
     }
     return 0;
 }
-static FX_BOOL CheckDirectType(CPDF_Dictionary* pDict, const CFX_ByteStringC& key, int32_t iType)
+static bool CheckDirectType(CPDF_Dictionary* pDict, const CFX_ByteStringC& key, int32_t iType)
 {
     CPDF_Object* pObj = pDict->GetElement(key);
     if (!pObj) {
-        return TRUE;
+        return true;
     }
     return pObj->GetType() == iType;
 }
-FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos)
+bool CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos)
 {
-    if (!LoadCrossRefV4(xrefpos, 0, TRUE, FALSE)) {
-        return FALSE;
+    if (!LoadCrossRefV4(xrefpos, 0, true, false)) {
+        return false;
     }
     m_pTrailer = LoadTrailerV4();
     if (m_pTrailer == NULL) {
-        return FALSE;
+        return false;
     }
     int32_t xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size"));
     if (xrefsize <= 0 || xrefsize > (1 << 20)) {
-        return FALSE;
+        return false;
     }
     m_CrossRef.SetSize(xrefsize);
     m_V5Type.SetSize(xrefsize);
@@ -367,51 +367,51 @@ FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos)
     CrossRefList.Add(xrefpos);
     XRefStreamList.Add(GetDirectInteger(m_pTrailer, FX_BSTRC("XRefStm")));
     if (!CheckDirectType(m_pTrailer, FX_BSTRC("Prev"), PDFOBJ_NUMBER)) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE newxrefpos = GetDirectInteger(m_pTrailer, FX_BSTRC("Prev"));
     if (newxrefpos == xrefpos) {
-        return FALSE;
+        return false;
     }
     xrefpos = newxrefpos;
     while (xrefpos) {
         CrossRefList.InsertAt(0, xrefpos);
-        LoadCrossRefV4(xrefpos, 0, TRUE, FALSE);
+        LoadCrossRefV4(xrefpos, 0, true, false);
         CPDF_Dictionary* pDict = LoadTrailerV4();
         if (pDict == NULL) {
-            return FALSE;
+            return false;
         }
         if (!CheckDirectType(pDict, FX_BSTRC("Prev"), PDFOBJ_NUMBER)) {
             pDict->Release();
-            return FALSE;
+            return false;
         }
         newxrefpos = GetDirectInteger(pDict, FX_BSTRC("Prev"));
         if (newxrefpos == xrefpos) {
             pDict->Release();
-            return FALSE;
+            return false;
         }
         xrefpos = newxrefpos;
         XRefStreamList.InsertAt(0, pDict->GetInteger(FX_BSTRC("XRefStm")));
         m_Trailers.Add(pDict);
     }
     for (int32_t i = 0; i < CrossRefList.GetSize(); i ++)
-        if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) {
-            return FALSE;
+        if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], false, i == 0)) {
+            return false;
         }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos, FX_DWORD dwObjCount)
+bool CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos, FX_DWORD dwObjCount)
 {
     if (!LoadLinearizedCrossRefV4(xrefpos, dwObjCount)) {
-        return FALSE;
+        return false;
     }
     m_pTrailer = LoadTrailerV4();
     if (m_pTrailer == NULL) {
-        return FALSE;
+        return false;
     }
     int32_t xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size"));
     if (xrefsize == 0) {
-        return FALSE;
+        return false;
     }
     CFX_FileSizeArray CrossRefList, XRefStreamList;
     CrossRefList.Add(xrefpos);
@@ -419,22 +419,22 @@ FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV4(FX_FILESIZE xrefpos, FX_DWORD d
     xrefpos = GetDirectInteger(m_pTrailer, FX_BSTRC("Prev"));
     while (xrefpos) {
         CrossRefList.InsertAt(0, xrefpos);
-        LoadCrossRefV4(xrefpos, 0, TRUE, FALSE);
+        LoadCrossRefV4(xrefpos, 0, true, false);
         CPDF_Dictionary* pDict = LoadTrailerV4();
         if (pDict == NULL) {
-            return FALSE;
+            return false;
         }
         xrefpos = GetDirectInteger(pDict, FX_BSTRC("Prev"));
         XRefStreamList.InsertAt(0, pDict->GetInteger(FX_BSTRC("XRefStm")));
         m_Trailers.Add(pDict);
     }
     for (int32_t i = 1; i < CrossRefList.GetSize(); i ++)
-        if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) {
-            return FALSE;
+        if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], false, i == 0)) {
+            return false;
         }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount)
+bool CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount)
 {
     FX_FILESIZE dwStartPos = pos - m_Syntax.m_HeaderOffset;
     m_Syntax.RestorePos(dwStartPos);
@@ -454,11 +454,11 @@ FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCou
         FX_DWORD dwReadSize = block_size * recordsize;
         if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_Syntax.m_FileLen) {
             FX_Free(pBuf);
-            return FALSE;
+            return false;
         }
         if (!m_Syntax.ReadBlock((uint8_t*)pBuf, dwReadSize)) {
             FX_Free(pBuf);
-            return FALSE;
+            return false;
         }
         for (int32_t i = 0; i < block_size; i ++) {
             FX_DWORD objnum = start_objnum + block * 1024 + i;
@@ -472,14 +472,14 @@ FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCou
                     for (int32_t c = 0; c < 10; c ++) {
                         if (pEntry[c] < '0' || pEntry[c] > '9') {
                             FX_Free(pBuf);
-                            return FALSE;
+                            return false;
                         }
                     }
                 }
                 m_CrossRef.SetAtGrow(objnum, offset);
                 int32_t version = FXSYS_atoi(pEntry + 11);
                 if (version >= 1) {
-                    m_bVersionUpdated = TRUE;
+                    m_bVersionUpdated = true;
                 }
                 m_ObjVersion.SetAtGrow(objnum, version);
                 if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
@@ -494,13 +494,13 @@ FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCou
     }
     FX_Free(pBuf);
     m_Syntax.RestorePos(SavedPos + count * recordsize);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_BOOL bSkip, FX_BOOL bFirst)
+bool CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, bool bSkip, bool bFirst)
 {
     m_Syntax.RestorePos(pos);
     if (m_Syntax.GetKeyword() != FX_BSTRC("xref")) {
-        return FALSE;
+        return false;
     }
     void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
@@ -514,10 +514,10 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
     }
     while (1) {
         FX_FILESIZE SavedPos = m_Syntax.SavePos();
-        FX_BOOL bIsNumber;
+        bool bIsNumber;
         CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
         if (word.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (!bIsNumber) {
             m_Syntax.RestorePos(SavedPos);
@@ -525,22 +525,22 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
         }
         FX_DWORD start_objnum = FXSYS_atoi(word);
         if (start_objnum >= (1 << 20)) {
-            return FALSE;
+            return false;
         }
         FX_DWORD count = m_Syntax.GetDirectNum();
         m_Syntax.ToNextWord();
         SavedPos = m_Syntax.SavePos();
-        FX_BOOL bFirstItem = FALSE;
+        bool bFirstItem = false;
         int32_t recordsize = 20;
         if (bFirst) {
-            bFirstItem = TRUE;
+            bFirstItem = true;
         }
         m_dwXrefStartObjNum = start_objnum;
         if (!bSkip) {
             char* pBuf = FX_Alloc(char, 1024 * recordsize + 1);
             pBuf[1024 * recordsize] = '\0';
             int32_t nBlocks = count / 1024 + 1;
-            FX_BOOL bFirstBlock = TRUE;
+            bool bFirstBlock = true;
             for (int32_t block = 0; block < nBlocks; block ++) {
                 int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
                 m_Syntax.ReadBlock((uint8_t*)pBuf, block_size * recordsize);
@@ -550,7 +550,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
                     if (pEntry[17] == 'f') {
                         if (bFirstItem) {
                             objnum = 0;
-                            bFirstItem = FALSE;
+                            bFirstItem = false;
                         }
                         if (bFirstBlock) {
                             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
@@ -568,14 +568,14 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
                             for (int32_t c = 0; c < 10; c ++) {
                                 if (pEntry[c] < '0' || pEntry[c] > '9') {
                                     FX_Free(pBuf);
-                                    return FALSE;
+                                    return false;
                                 }
                             }
                         }
                         m_CrossRef.SetAtGrow(objnum, offset);
                         int32_t version = FXSYS_atoi(pEntry + 11);
                         if (version >= 1) {
-                            m_bVersionUpdated = TRUE;
+                            m_bVersionUpdated = true;
                         }
                         m_ObjVersion.SetAtGrow(objnum, version);
                         if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
@@ -587,7 +587,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
                         m_V5Type.SetAtGrow(objnum, 1);
                     }
                     if (bFirstBlock) {
-                        bFirstBlock = FALSE;
+                        bFirstBlock = false;
                     }
                 }
             }
@@ -596,25 +596,25 @@ FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_B
         m_Syntax.RestorePos(SavedPos + count * recordsize);
     }
     if (streampos)
-        if (!LoadCrossRefV5(streampos, streampos, FALSE)) {
-            return FALSE;
+        if (!LoadCrossRefV5(streampos, streampos, false)) {
+            return false;
         }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos)
+bool CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos)
 {
-    if (!LoadCrossRefV5(xrefpos, xrefpos, TRUE)) {
-        return FALSE;
+    if (!LoadCrossRefV5(xrefpos, xrefpos, true)) {
+        return false;
     }
     while (xrefpos)
-        if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
-            return FALSE;
+        if (!LoadCrossRefV5(xrefpos, xrefpos, false)) {
+            return false;
         }
-    m_ObjectStreamMap.InitHashTable(101, FALSE);
-    m_bXRefStream = TRUE;
-    return TRUE;
+    m_ObjectStreamMap.InitHashTable(101, false);
+    m_bXRefStream = true;
+    return true;
 }
-FX_BOOL CPDF_Parser::RebuildCrossRef()
+bool CPDF_Parser::RebuildCrossRef()
 {
     m_CrossRef.RemoveAll();
     m_V5Type.RemoveAll();
@@ -633,7 +633,7 @@ FX_BOOL CPDF_Parser::RebuildCrossRef()
     FX_FILESIZE start_pos = 0, start_pos1 = 0;
     FX_FILESIZE last_obj = -1, last_xref = -1, last_trailer = -1;
     while (pos < m_Syntax.m_FileLen) {
-        FX_BOOL bOverFlow = FALSE;
+        bool bOverFlow = false;
         FX_DWORD size = (FX_DWORD)(m_Syntax.m_FileLen - pos);
         if (size > 4096) {
             size = 4096;
@@ -812,7 +812,7 @@ FX_BOOL CPDF_Parser::RebuildCrossRef()
                                 FX_FILESIZE nLen = obj_end - obj_pos - offset;
                                 if ((FX_DWORD)nLen > size - i) {
                                     pos = obj_end + m_Syntax.m_HeaderOffset;
-                                    bOverFlow = TRUE;
+                                    bOverFlow = true;
                                 } else {
                                     i += (FX_DWORD)nLen;
                                 }
@@ -822,7 +822,7 @@ FX_BOOL CPDF_Parser::RebuildCrossRef()
                                         m_CrossRef[objnum] = obj_pos;
                                         m_ObjVersion.SetAt(objnum, (int16_t)gennum);
                                         if (oldgen != gennum) {
-                                            m_bVersionUpdated = TRUE;
+                                            m_bVersionUpdated = true;
                                         }
                                     }
                                 } else {
@@ -881,7 +881,7 @@ FX_BOOL CPDF_Parser::RebuildCrossRef()
                                             FX_FILESIZE dwSavePos = m_Syntax.SavePos();
                                             CFX_ByteString strWord = m_Syntax.GetKeyword();
                                             if (!strWord.Compare(FX_BSTRC("startxref"))) {
-                                                FX_BOOL bNumber = FALSE;
+                                                bool bNumber = false;
                                                 CFX_ByteString bsOffset = m_Syntax.GetNextWord(bNumber);
                                                 if (bNumber) {
                                                     m_LastXRefOffset = FXSYS_atoi(bsOffset);
@@ -982,7 +982,7 @@ FX_BOOL CPDF_Parser::RebuildCrossRef()
         m_SortedOffset.Add(offset);
     }
     FX_Free(buffer);
-    return TRUE;
+    return true;
 }
 static FX_DWORD _GetVarInt(const uint8_t* p, int32_t n)
 {
@@ -992,11 +992,11 @@ static FX_DWORD _GetVarInt(const uint8_t* p, int32_t n)
     }
     return result;
 }
-FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL bMainXRef)
+bool CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, bool bMainXRef)
 {
     CPDF_Stream* pStream = (CPDF_Stream*)ParseIndirectObjectAt(m_pDocument, pos, 0, NULL);
     if (!pStream) {
-        return FALSE;
+        return false;
     }
     if (m_pDocument) {
         CPDF_Dictionary * pDict = m_pDocument->GetRoot();
@@ -1006,17 +1006,17 @@ FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL
             if (pStream->GetType() == PDFOBJ_STREAM) {
                 pStream->Release();
             }
-            return FALSE;
+            return false;
         }
     }
     if (pStream->GetType() != PDFOBJ_STREAM) {
-        return FALSE;
+        return false;
     }
     prev = pStream->GetDict()->GetInteger(FX_BSTRC("Prev"));
     int32_t size = pStream->GetDict()->GetInteger(FX_BSTRC("Size"));
     if (size < 0) {
         pStream->Release();
-        return FALSE;
+        return false;
     }
     if (bMainXRef) {
         m_pTrailer = (CPDF_Dictionary*)pStream->GetDict()->Clone();
@@ -1050,7 +1050,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL
     pArray = pStream->GetDict()->GetArray(FX_BSTRC("W"));
     if (pArray == NULL) {
         pStream->Release();
-        return FALSE;
+        return false;
     }
     CFX_DWordArray WidthArray;
     FX_SAFE_DWORD dwAccWidth = 0;
@@ -1060,7 +1060,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL
     }
     if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3) {
         pStream->Release();
-        return FALSE;
+        return false;
     }
     FX_DWORD totalWidth = dwAccWidth.ValueOrDie();
     CPDF_StreamAcc acc;
@@ -1120,7 +1120,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL
                 } else {
                     if (offset < 0 || offset >= m_V5Type.GetSize()) {
                         pStream->Release();
-                        return FALSE;
+                        return false;
                     }
                     m_V5Type[offset] = 255;
                 }
@@ -1129,7 +1129,7 @@ FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL
         segindex += count;
     }
     pStream->Release();
-    return TRUE;
+    return true;
 }
 CPDF_Array* CPDF_Parser::GetIDArray()
 {
@@ -1162,32 +1162,32 @@ FX_DWORD CPDF_Parser::GetInfoObjNum()
     }
     return ((CPDF_Reference*) pRef)->GetRefObjNum();
 }
-FX_BOOL CPDF_Parser::IsFormStream(FX_DWORD objnum, FX_BOOL& bForm)
+bool CPDF_Parser::IsFormStream(FX_DWORD objnum, bool& bForm)
 {
-    bForm = FALSE;
+    bForm = false;
     if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
-        return TRUE;
+        return true;
     }
     if (m_V5Type[objnum] == 0) {
-        return TRUE;
+        return true;
     }
     if (m_V5Type[objnum] == 2) {
-        return TRUE;
+        return true;
     }
     FX_FILESIZE pos = m_CrossRef[objnum];
     void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
-        return TRUE;
+        return true;
     }
     if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE size = ((FX_FILESIZE*)pResult)[1] - pos;
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
     m_Syntax.RestorePos(pos);
-    bForm = m_Syntax.SearchMultiWord(FX_BSTRC("/Form\0stream"), TRUE, size) == 0;
+    bForm = m_Syntax.SearchMultiWord(FX_BSTRC("/Form\0stream"), true, size) == 0;
     m_Syntax.RestorePos(SavedPos);
-    return TRUE;
+    return true;
 }
 CPDF_Object* CPDF_Parser::ParseIndirectObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, PARSE_CONTEXT* pContext)
 {
@@ -1209,7 +1209,7 @@ CPDF_Object* CPDF_Parser::ParseIndirectObject(CPDF_IndirectObjects* pObjList, FX
         int32_t n = pObjStream->GetDict()->GetInteger(FX_BSTRC("N"));
         int32_t offset = pObjStream->GetDict()->GetInteger(FX_BSTRC("First"));
         CPDF_SyntaxParser syntax;
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), false));
         syntax.InitParser(file.Get(), 0);
         CPDF_Object* pRet = NULL;
         while (n) {
@@ -1282,7 +1282,7 @@ void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD
         CPDF_SyntaxParser syntax;
         const uint8_t* pData = pObjStream->GetData();
         FX_DWORD totalsize = pObjStream->GetSize();
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, false));
         syntax.InitParser(file.Get(), 0);
         while (n) {
             FX_DWORD thisnum = syntax.GetDirectNum();
@@ -1310,7 +1310,7 @@ void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD
         }
         FX_FILESIZE SavedPos = m_Syntax.SavePos();
         m_Syntax.RestorePos(pos);
-        FX_BOOL bIsNumber;
+        bool bIsNumber;
         CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
         if (!bIsNumber) {
             m_Syntax.RestorePos(SavedPos);
@@ -1336,16 +1336,16 @@ void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD
             return;
         }
         FX_FILESIZE nextoff = ((FX_FILESIZE*)pResult)[1];
-        FX_BOOL bNextOffValid = FALSE;
+        bool bNextOffValid = false;
         if (nextoff != pos) {
             m_Syntax.RestorePos(nextoff);
             word = m_Syntax.GetNextWord(bIsNumber);
             if (word == FX_BSTRC("xref")) {
-                bNextOffValid = TRUE;
+                bNextOffValid = true;
             } else if (bIsNumber) {
                 word = m_Syntax.GetNextWord(bIsNumber);
                 if (bIsNumber && m_Syntax.GetKeyword() == FX_BSTRC("obj")) {
-                    bNextOffValid = TRUE;
+                    bNextOffValid = true;
                 }
             }
         }
@@ -1373,7 +1373,7 @@ CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(CPDF_IndirectObjects* pObjList,
 {
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
     m_Syntax.RestorePos(pos);
-    FX_BOOL bIsNumber;
+    bool bIsNumber;
     CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
     if (!bIsNumber) {
         m_Syntax.RestorePos(SavedPos);
@@ -1416,7 +1416,7 @@ CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(CPDF_IndirectObjects* pO
 {
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
     m_Syntax.RestorePos(pos);
-    FX_BOOL bIsNumber;
+    bool bIsNumber;
     CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
     if (!bIsNumber) {
         m_Syntax.RestorePos(SavedPos);
@@ -1458,7 +1458,7 @@ CPDF_Dictionary* CPDF_Parser::LoadTrailerV4()
     }
     return (CPDF_Dictionary*)pObj;
 }
-FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision)
+FX_DWORD CPDF_Parser::GetPermissions(bool bCheckRevision)
 {
     if (m_pSecurityHandler == NULL) {
         return (FX_DWORD) - 1;
@@ -1473,11 +1473,11 @@ FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision)
     }
     return dwPermission;
 }
-FX_BOOL CPDF_Parser::IsOwner()
+bool CPDF_Parser::IsOwner()
 {
-    return m_pSecurityHandler == NULL ? TRUE : m_pSecurityHandler->IsOwner();
+    return m_pSecurityHandler == NULL ? true : m_pSecurityHandler->IsOwner();
 }
-void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler, FX_BOOL bForced)
+void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler, bool bForced)
 {
     ASSERT(m_pSecurityHandler == NULL);
     if (!m_bForceUseSecurityHandler) {
@@ -1492,29 +1492,29 @@ void CPDF_Parser::SetSecurityHandler(CPDF_SecurityHandler* pSecurityHandler, FX_
     m_Syntax.m_pCryptoHandler = pSecurityHandler->CreateCryptoHandler();
     m_Syntax.m_pCryptoHandler->Init(NULL, pSecurityHandler);
 }
-FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset)
+bool CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset)
 {
     m_Syntax.InitParser(pFileAccess, offset);
     m_Syntax.RestorePos(m_Syntax.m_HeaderOffset + 9);
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
-    FX_BOOL bIsNumber;
+    bool bIsNumber;
     CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
     if (!bIsNumber) {
-        return FALSE;
+        return false;
     }
     FX_DWORD objnum = FXSYS_atoi(word);
     word = m_Syntax.GetNextWord(bIsNumber);
     if (!bIsNumber) {
-        return FALSE;
+        return false;
     }
     FX_DWORD gennum = FXSYS_atoi(word);
     if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) {
         m_Syntax.RestorePos(SavedPos);
-        return FALSE;
+        return false;
     }
     m_pLinearized = m_Syntax.GetObject(NULL, objnum, gennum, 0);
     if (!m_pLinearized) {
-        return FALSE;
+        return false;
     }
     if (m_pLinearized->GetDict() && m_pLinearized->GetDict()->GetElement(FX_BSTRC("Linearized"))) {
         m_Syntax.GetNextWord(bIsNumber);
@@ -1522,10 +1522,10 @@ FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset
         if (!pLen) {
             m_pLinearized->Release();
             m_pLinearized = NULL;
-            return FALSE;
+            return false;
         }
         if (pLen->GetInteger() != (int)pFileAccess->GetSize()) {
-            return FALSE;
+            return false;
         }
         CPDF_Object *pNo = m_pLinearized->GetDict()->GetElement(FX_BSTRC("P"));
         if (pNo && pNo->GetType() == PDFOBJ_NUMBER) {
@@ -1535,16 +1535,16 @@ FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess, FX_DWORD offset
         if (pTable && pTable->GetType() == PDFOBJ_NUMBER) {
             m_LastXRefOffset = pTable->GetInteger();
         }
-        return TRUE;
+        return true;
     }
     m_pLinearized->Release();
     m_pLinearized = NULL;
-    return FALSE;
+    return false;
 }
-FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX_BOOL bOwnFileRead)
+FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess, bool bReParse, bool bOwnFileRead)
 {
     CloseParser(bReParse);
-    m_bXRefStream = FALSE;
+    m_bXRefStream = false;
     m_LastXRefOffset = 0;
     m_bOwnFileRead = bOwnFileRead;
     int32_t offset = GetHeaderOffset(pFileAccess);
@@ -1559,19 +1559,19 @@ FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse
         m_pDocument = new CPDF_Document(this);
     }
     FX_FILESIZE dwFirstXRefOffset = m_Syntax.SavePos();
-    FX_BOOL bXRefRebuilt = FALSE;
-    FX_BOOL bLoadV4 = FALSE;
-    if (!(bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE, FALSE)) && !LoadCrossRefV5(dwFirstXRefOffset, dwFirstXRefOffset, TRUE)) {
+    bool bXRefRebuilt = false;
+    bool bLoadV4 = false;
+    if (!(bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, false, false)) && !LoadCrossRefV5(dwFirstXRefOffset, dwFirstXRefOffset, true)) {
         if (!RebuildCrossRef()) {
             return PDFPARSE_ERROR_FORMAT;
         }
-        bXRefRebuilt = TRUE;
+        bXRefRebuilt = true;
         m_LastXRefOffset = 0;
     }
     if (bLoadV4) {
         m_pTrailer = LoadTrailerV4();
         if (m_pTrailer == NULL) {
-            return FALSE;
+            return false;
         }
         int32_t xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size"));
         if (xrefsize > 0) {
@@ -1623,18 +1623,18 @@ FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse
     }
     return PDFPARSE_ERROR_SUCCESS;
 }
-FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos)
+bool CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos)
 {
-    if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
-        return FALSE;
+    if (!LoadCrossRefV5(xrefpos, xrefpos, false)) {
+        return false;
     }
     while (xrefpos)
-        if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
-            return FALSE;
+        if (!LoadCrossRefV5(xrefpos, xrefpos, false)) {
+            return false;
         }
-    m_ObjectStreamMap.InitHashTable(101, FALSE);
-    m_bXRefStream = TRUE;
-    return TRUE;
+    m_ObjectStreamMap.InitHashTable(101, false);
+    m_bXRefStream = true;
+    return true;
 }
 FX_DWORD CPDF_Parser::LoadLinearizedMainXRefTable()
 {
@@ -1688,7 +1688,7 @@ CPDF_SyntaxParser::CPDF_SyntaxParser()
     m_pFileBuf = NULL;
     m_MetadataObjnum = 0;
     m_dwWordPos = 0;
-    m_bFileStream = FALSE;
+    m_bFileStream = false;
 }
 CPDF_SyntaxParser::~CPDF_SyntaxParser()
 {
@@ -1696,19 +1696,19 @@ CPDF_SyntaxParser::~CPDF_SyntaxParser()
         FX_Free(m_pFileBuf);
     }
 }
-FX_BOOL CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch)
+bool CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch)
 {
     FX_FILESIZE save_pos = m_Pos;
     m_Pos = pos;
-    FX_BOOL ret = GetNextChar(ch);
+    bool ret = GetNextChar(ch);
     m_Pos = save_pos;
     return ret;
 }
-FX_BOOL CPDF_SyntaxParser::GetNextChar(uint8_t& ch)
+bool CPDF_SyntaxParser::GetNextChar(uint8_t& ch)
 {
     FX_FILESIZE pos = m_Pos + m_HeaderOffset;
     if (pos >= m_FileLen) {
-        return FALSE;
+        return false;
     }
     if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
         FX_FILESIZE read_pos = pos;
@@ -1725,19 +1725,19 @@ FX_BOOL CPDF_SyntaxParser::GetNextChar(uint8_t& ch)
             }
         }
         if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size)) {
-            return FALSE;
+            return false;
         }
         m_BufOffset = read_pos;
     }
     ch = m_pFileBuf[pos - m_BufOffset];
     m_Pos ++;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch)
+bool CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch)
 {
     pos += m_HeaderOffset;
     if (pos >= m_FileLen) {
-        return FALSE;
+        return false;
     }
     if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
         FX_FILESIZE read_pos;
@@ -1756,26 +1756,26 @@ FX_BOOL CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch)
             }
         }
         if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size)) {
-            return FALSE;
+            return false;
         }
         m_BufOffset = read_pos;
     }
     ch = m_pFileBuf[pos - m_BufOffset];
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, FX_DWORD size)
+bool CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, FX_DWORD size)
 {
     if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size)) {
-        return FALSE;
+        return false;
     }
     m_Pos += size;
-    return TRUE;
+    return true;
 }
 #define MAX_WORD_BUFFER 256
 void CPDF_SyntaxParser::GetNextWord()
 {
     m_WordSize = 0;
-    m_bIsNumber = TRUE;
+    m_bIsNumber = true;
     uint8_t ch;
     if (!GetNextChar(ch)) {
         return;
@@ -1802,7 +1802,7 @@ void CPDF_SyntaxParser::GetNextWord()
         type = PDF_CharType[ch];
     }
     if (type == 'D') {
-        m_bIsNumber = FALSE;
+        m_bIsNumber = false;
         m_WordBuffer[m_WordSize++] = ch;
         if (ch == '/') {
             while (1) {
@@ -1844,7 +1844,7 @@ void CPDF_SyntaxParser::GetNextWord()
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (type != 'N') {
-            m_bIsNumber = FALSE;
+            m_bIsNumber = false;
         }
         if (!GetNextChar(ch)) {
             return;
@@ -1950,7 +1950,7 @@ CFX_ByteString CPDF_SyntaxParser::ReadHexString()
         return CFX_ByteString();
     }
     CFX_BinaryBuf buf;
-    FX_BOOL bFirst = TRUE;
+    bool bFirst = true;
     uint8_t code = 0;
     while (1) {
         if (ch == '>') {
@@ -2036,7 +2036,7 @@ void CPDF_SyntaxParser::ToNextWord()
     }
     m_Pos --;
 }
-CFX_ByteString CPDF_SyntaxParser::GetNextWord(FX_BOOL& bIsNumber)
+CFX_ByteString CPDF_SyntaxParser::GetNextWord(bool& bIsNumber)
 {
     GetNextWord();
     bIsNumber = m_bIsNumber;
@@ -2047,15 +2047,15 @@ CFX_ByteString CPDF_SyntaxParser::GetKeyword()
     GetNextWord();
     return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
-CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, PARSE_CONTEXT* pContext, FX_BOOL bDecrypt)
+CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, PARSE_CONTEXT* pContext, bool bDecrypt)
 {
     CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
     if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
         return NULL;
     }
     FX_FILESIZE SavedPos = m_Pos;
-    FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
-    FX_BOOL bIsNumber;
+    bool bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
+    bool bIsNumber;
     CFX_ByteString word = GetNextWord(bIsNumber);
     if (word.GetLength() == 0) {
         if (bTypeOnly) {
@@ -2102,7 +2102,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWO
         if (m_pCryptoHandler && bDecrypt) {
             m_pCryptoHandler->Decrypt(objnum, gennum, str);
         }
-        return CPDF_String::Create(str, FALSE);
+        return CPDF_String::Create(str, false);
     }
     if (word == FX_BSTRC("<")) {
         if (bTypeOnly) {
@@ -2112,7 +2112,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWO
         if (m_pCryptoHandler && bDecrypt) {
             m_pCryptoHandler->Decrypt(objnum, gennum, str);
         }
-        return CPDF_String::Create(str, TRUE);
+        return CPDF_String::Create(str, true);
     }
     if (word == FX_BSTRC("[")) {
         if (bTypeOnly) {
@@ -2145,7 +2145,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWO
         int32_t nKeys = 0;
         FX_FILESIZE dwSignValuePos = 0;
         while (1) {
-            FX_BOOL bIsNumber;
+            bool bIsNumber;
             CFX_ByteString key = GetNextWord(bIsNumber);
             if (key.IsEmpty()) {
                 if (pDict)
@@ -2183,7 +2183,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWO
         if (IsSignatureDict(pDict)) {
             FX_FILESIZE dwSavePos = m_Pos;
             m_Pos = dwSignValuePos;
-            CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, NULL, FALSE);
+            CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, NULL, false);
             pDict->SetAt(FX_BSTRC("Contents"), pObj);
             m_Pos = dwSavePos;
         }
@@ -2194,7 +2194,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWO
             }
         }
         FX_FILESIZE SavedPos = m_Pos;
-        FX_BOOL bIsNumber;
+        bool bIsNumber;
         CFX_ByteString nextword = GetNextWord(bIsNumber);
         if (nextword == FX_BSTRC("stream")) {
             CPDF_Stream* pStream = ReadStream(pDict, pContext, objnum, gennum);
@@ -2225,8 +2225,8 @@ CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList
         return NULL;
     }
     FX_FILESIZE SavedPos = m_Pos;
-    FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
-    FX_BOOL bIsNumber;
+    bool bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
+    bool bIsNumber;
     CFX_ByteString word = GetNextWord(bIsNumber);
     if (word.GetLength() == 0) {
         if (bTypeOnly) {
@@ -2273,7 +2273,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList
         if (m_pCryptoHandler) {
             m_pCryptoHandler->Decrypt(objnum, gennum, str);
         }
-        return CPDF_String::Create(str, FALSE);
+        return CPDF_String::Create(str, false);
     }
     if (word == FX_BSTRC("<")) {
         if (bTypeOnly) {
@@ -2283,7 +2283,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList
         if (m_pCryptoHandler) {
             m_pCryptoHandler->Decrypt(objnum, gennum, str);
         }
-        return CPDF_String::Create(str, TRUE);
+        return CPDF_String::Create(str, true);
     }
     if (word == FX_BSTRC("[")) {
         if (bTypeOnly) {
@@ -2319,7 +2319,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList
         }
         CPDF_Dictionary* pDict = CPDF_Dictionary::Create();
         while (1) {
-            FX_BOOL bIsNumber;
+            bool bIsNumber;
             FX_FILESIZE SavedPos = m_Pos;
             CFX_ByteString key = GetNextWord(bIsNumber);
             if (key.IsEmpty()) {
@@ -2366,7 +2366,7 @@ CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(CPDF_IndirectObjects* pObjList
             }
         }
         FX_FILESIZE SavedPos = m_Pos;
-        FX_BOOL bIsNumber;
+        bool bIsNumber;
         CFX_ByteString nextword = GetNextWord(bIsNumber);
         if (nextword == FX_BSTRC("stream")) {
             CPDF_Stream* pStream = ReadStream(pDict, pContext, objnum, gennum);
@@ -2495,32 +2495,32 @@ int32_t CPDF_SyntaxParser::GetDirectNum()
     m_WordBuffer[m_WordSize] = 0;
     return FXSYS_atoi((const FX_CHAR*)m_WordBuffer);
 }
-FX_BOOL CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, const uint8_t* tag, FX_DWORD taglen)
+bool CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, const uint8_t* tag, FX_DWORD taglen)
 {
     uint8_t type = PDF_CharType[tag[0]];
-    FX_BOOL bCheckLeft = type != 'D' && type != 'W';
+    bool bCheckLeft = type != 'D' && type != 'W';
     type = PDF_CharType[tag[taglen - 1]];
-    FX_BOOL bCheckRight = type != 'D' && type != 'W';
+    bool bCheckRight = type != 'D' && type != 'W';
     uint8_t ch;
     if (bCheckRight && startpos + (int32_t)taglen <= limit && GetCharAt(startpos + (int32_t)taglen, ch)) {
         uint8_t type = PDF_CharType[ch];
         if (type == 'N' || type == 'R') {
-            return FALSE;
+            return false;
         }
     }
     if (bCheckLeft && startpos > 0 && GetCharAt(startpos - 1, ch)) {
         uint8_t type = PDF_CharType[ch];
         if (type == 'N' || type == 'R') {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag, FX_BOOL bWholeWord, FX_BOOL bForward, FX_FILESIZE limit)
+bool CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag, bool bWholeWord, bool bForward, FX_FILESIZE limit)
 {
     int32_t taglen = tag.GetLength();
     if (taglen == 0) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE pos = m_Pos;
     int32_t offset = 0;
@@ -2533,20 +2533,20 @@ FX_BOOL CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag, FX_BOOL bWhole
         if (bForward) {
             if (limit) {
                 if (pos >= m_Pos + limit) {
-                    return FALSE;
+                    return false;
                 }
             }
             if (!GetCharAt(pos, byte)) {
-                return FALSE;
+                return false;
             }
         } else {
             if (limit) {
                 if (pos <= m_Pos - limit) {
-                    return FALSE;
+                    return false;
                 }
             }
             if (!GetCharAtBackward(pos, byte)) {
-                return FALSE;
+                return false;
             }
         }
         if (byte == tag_data[offset]) {
@@ -2566,7 +2566,7 @@ FX_BOOL CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag, FX_BOOL bWhole
             FX_FILESIZE startpos = bForward ? pos - taglen + 1 : pos;
             if (!bWholeWord || IsWholeWord(startpos, limit, tag.GetPtr(), taglen)) {
                 m_Pos = startpos;
-                return TRUE;
+                return true;
             }
         }
         if (bForward) {
@@ -2577,17 +2577,17 @@ FX_BOOL CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag, FX_BOOL bWhole
             pos --;
         }
         if (pos < 0) {
-            return FALSE;
+            return false;
         }
     }
-    return FALSE;
+    return false;
 }
 struct _SearchTagRecord {
     const uint8_t*	m_pTag;
     FX_DWORD	m_Len;
     FX_DWORD	m_Offset;
 };
-int32_t CPDF_SyntaxParser::SearchMultiWord(const CFX_ByteStringC& tags, FX_BOOL bWholeWord, FX_FILESIZE limit)
+int32_t CPDF_SyntaxParser::SearchMultiWord(const CFX_ByteStringC& tags, bool bWholeWord, FX_FILESIZE limit)
 {
     int32_t ntags = 1, i;
     for (i = 0; i < tags.GetLength(); i ++)
@@ -2695,17 +2695,17 @@ public:
     CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
     ~CPDF_DataAvail();
 
-    virtual FX_BOOL                     IsDocAvail(IFX_DownloadHints* pHints)  override;
+    virtual bool                     IsDocAvail(IFX_DownloadHints* pHints)  override;
 
     virtual void                        SetDocument(CPDF_Document* pDoc)  override;
 
-    virtual FX_BOOL                     IsPageAvail(int iPage, IFX_DownloadHints* pHints)  override;
+    virtual bool                     IsPageAvail(int iPage, IFX_DownloadHints* pHints)  override;
 
     virtual int32_t                     IsFormAvail(IFX_DownloadHints *pHints)  override;
 
     virtual int32_t                     IsLinearizedPDF()  override;
 
-    virtual FX_BOOL                     IsLinearized()  override
+    virtual bool                     IsLinearized()  override
     {
         return m_bLinearized;
     }
@@ -2717,52 +2717,52 @@ protected:
     static int s_CurrentDataAvailRecursionDepth;
 
     FX_DWORD                            GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset);
-    FX_BOOL                             IsObjectsAvail(CFX_PtrArray& obj_array, FX_BOOL bParsePage, IFX_DownloadHints* pHints, CFX_PtrArray &ret_array);
-    FX_BOOL                             CheckDocStatus(IFX_DownloadHints *pHints);
-    FX_BOOL                             CheckHeader(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckFirstPage(IFX_DownloadHints *pHints);
-    FX_BOOL                             CheckEnd(IFX_DownloadHints *pHints);
-    FX_BOOL                             CheckCrossRef(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckCrossRefItem(IFX_DownloadHints *pHints);
-    FX_BOOL                             CheckTrailer(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckRoot(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckInfo(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPages(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPage(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckResources(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckAnnots(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckAcroForm(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckAcroFormSubObject(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckTrailerAppend(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPageStatus(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckAllCrossRefStream(IFX_DownloadHints *pHints);
+    bool                             IsObjectsAvail(CFX_PtrArray& obj_array, bool bParsePage, IFX_DownloadHints* pHints, CFX_PtrArray &ret_array);
+    bool                             CheckDocStatus(IFX_DownloadHints *pHints);
+    bool                             CheckHeader(IFX_DownloadHints* pHints);
+    bool                             CheckFirstPage(IFX_DownloadHints *pHints);
+    bool                             CheckEnd(IFX_DownloadHints *pHints);
+    bool                             CheckCrossRef(IFX_DownloadHints* pHints);
+    bool                             CheckCrossRefItem(IFX_DownloadHints *pHints);
+    bool                             CheckTrailer(IFX_DownloadHints* pHints);
+    bool                             CheckRoot(IFX_DownloadHints* pHints);
+    bool                             CheckInfo(IFX_DownloadHints* pHints);
+    bool                             CheckPages(IFX_DownloadHints* pHints);
+    bool                             CheckPage(IFX_DownloadHints* pHints);
+    bool                             CheckResources(IFX_DownloadHints* pHints);
+    bool                             CheckAnnots(IFX_DownloadHints* pHints);
+    bool                             CheckAcroForm(IFX_DownloadHints* pHints);
+    bool                             CheckAcroFormSubObject(IFX_DownloadHints* pHints);
+    bool                             CheckTrailerAppend(IFX_DownloadHints* pHints);
+    bool                             CheckPageStatus(IFX_DownloadHints* pHints);
+    bool                             CheckAllCrossRefStream(IFX_DownloadHints *pHints);
 
     int32_t                            CheckCrossRefStream(IFX_DownloadHints *pHints, FX_FILESIZE &xref_offset);
-    FX_BOOL                             IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen);
+    bool                             IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen);
     void                                SetStartOffset(FX_FILESIZE dwOffset);
-    FX_BOOL                             GetNextToken(CFX_ByteString &token);
-    FX_BOOL                             GetNextChar(uint8_t &ch);
+    bool                             GetNextToken(CFX_ByteString &token);
+    bool                             GetNextChar(uint8_t &ch);
     CPDF_Object	*                       ParseIndirectObjectAt(FX_FILESIZE pos, FX_DWORD objnum);
-    CPDF_Object	*                       GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, FX_BOOL *pExistInFile);
-    FX_BOOL                             GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages);
-    FX_BOOL                             PreparePageItem();
-    FX_BOOL                             LoadPages(IFX_DownloadHints* pHints);
-    FX_BOOL                             LoadAllXref(IFX_DownloadHints* pHints);
-    FX_BOOL                             LoadAllFile(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckLinearizedData(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckFileResources(IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPageAnnots(int iPage, IFX_DownloadHints* pHints);
+    CPDF_Object	*                       GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, bool *pExistInFile);
+    bool                             GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages);
+    bool                             PreparePageItem();
+    bool                             LoadPages(IFX_DownloadHints* pHints);
+    bool                             LoadAllXref(IFX_DownloadHints* pHints);
+    bool                             LoadAllFile(IFX_DownloadHints* pHints);
+    bool                             CheckLinearizedData(IFX_DownloadHints* pHints);
+    bool                             CheckFileResources(IFX_DownloadHints* pHints);
+    bool                             CheckPageAnnots(int iPage, IFX_DownloadHints* pHints);
 
-    FX_BOOL                             CheckLinearizedFirstPage(int iPage, IFX_DownloadHints* pHints);
-    FX_BOOL                             HaveResourceAncestor(CPDF_Dictionary *pDict);
-    FX_BOOL                             CheckPage(int32_t iPage, IFX_DownloadHints* pHints);
-    FX_BOOL                             LoadDocPages(IFX_DownloadHints* pHints);
-    FX_BOOL                             LoadDocPage(int32_t iPage, IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, int32_t &iCount, IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints);
-    FX_BOOL                             CheckPageCount(IFX_DownloadHints* pHints);
-    FX_BOOL                             IsFirstCheck(int iPage);
+    bool                             CheckLinearizedFirstPage(int iPage, IFX_DownloadHints* pHints);
+    bool                             HaveResourceAncestor(CPDF_Dictionary *pDict);
+    bool                             CheckPage(int32_t iPage, IFX_DownloadHints* pHints);
+    bool                             LoadDocPages(IFX_DownloadHints* pHints);
+    bool                             LoadDocPage(int32_t iPage, IFX_DownloadHints* pHints);
+    bool                             CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, int32_t &iCount, IFX_DownloadHints* pHints);
+    bool                             CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints);
+    bool                             CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints);
+    bool                             CheckPageCount(IFX_DownloadHints* pHints);
+    bool                             IsFirstCheck(int iPage);
     void                                ResetFirstCheck(int iPage);
 
     CPDF_Parser                         m_parser;
@@ -2779,7 +2779,7 @@ protected:
 
     CPDF_Object                         *m_pTrailer;
 
-    FX_BOOL                             m_bDocAvail;
+    bool                             m_bDocAvail;
 
     FX_FILESIZE                         m_dwHeaderOffset;
 
@@ -2823,31 +2823,31 @@ protected:
 
     FX_DWORD                            m_PagesObjNum;
 
-    FX_BOOL                             m_bLinearized;
+    bool                             m_bLinearized;
 
     FX_DWORD                            m_dwFirstPageNo;
 
-    FX_BOOL                             m_bLinearedDataOK;
+    bool                             m_bLinearedDataOK;
 
-    FX_BOOL                             m_bMainXRefLoadTried;
+    bool                             m_bMainXRefLoadTried;
 
-    FX_BOOL                             m_bMainXRefLoadedOK;
+    bool                             m_bMainXRefLoadedOK;
 
-    FX_BOOL                             m_bPagesTreeLoad;
+    bool                             m_bPagesTreeLoad;
 
-    FX_BOOL                             m_bPagesLoad;
+    bool                             m_bPagesLoad;
 
     CPDF_Parser *                       m_pCurrentParser;
 
     FX_FILESIZE                         m_dwCurrentXRefSteam;
 
-    FX_BOOL                             m_bAnnotsLoad;
+    bool                             m_bAnnotsLoad;
 
-    FX_BOOL                             m_bHaveAcroForm;
+    bool                             m_bHaveAcroForm;
 
     FX_DWORD                            m_dwAcroFormObjNum;
 
-    FX_BOOL                             m_bAcroFormLoad;
+    bool                             m_bAcroFormLoad;
 
     CPDF_Object	*                       m_pAcroForm;
 
@@ -2857,11 +2857,11 @@ protected:
 
     CPDF_Object *                       m_pPageResource;
 
-    FX_BOOL                             m_bNeedDownLoadResource;
+    bool                             m_bNeedDownLoadResource;
 
-    FX_BOOL                             m_bPageLoadedOK;
+    bool                             m_bPageLoadedOK;
 
-    FX_BOOL                             m_bLinearizedFormParamLoad;
+    bool                             m_bLinearizedFormParamLoad;
 
     CFX_PtrArray                        m_PagesArray;
 
@@ -2869,9 +2869,9 @@ protected:
 
     FX_FILESIZE                         m_dwPrevXRefOffset;
 
-    FX_BOOL                             m_bTotalLoadPageTree;
+    bool                             m_bTotalLoadPageTree;
 
-    FX_BOOL                             m_bCurPageDictLoadOK;
+    bool                             m_bCurPageDictLoadOK;
 
     CPDF_PageNode                       m_pageNodes;
 
@@ -2916,19 +2916,19 @@ CPDF_DataAvail::CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRea
     m_dwEncryptObjNum = 0;
     m_dwPrevXRefOffset = 0;
     m_dwLastXRefOffset = 0;
-    m_bDocAvail = FALSE;
-    m_bMainXRefLoadTried = FALSE;
-    m_bDocAvail = FALSE;
-    m_bLinearized = FALSE;
-    m_bPagesLoad = FALSE;
-    m_bPagesTreeLoad = FALSE;
-    m_bMainXRefLoadedOK = FALSE;
-    m_bAnnotsLoad = FALSE;
-    m_bHaveAcroForm = FALSE;
-    m_bAcroFormLoad = FALSE;
-    m_bPageLoadedOK = FALSE;
-    m_bNeedDownLoadResource = FALSE;
-    m_bLinearizedFormParamLoad = FALSE;
+    m_bDocAvail = false;
+    m_bMainXRefLoadTried = false;
+    m_bDocAvail = false;
+    m_bLinearized = false;
+    m_bPagesLoad = false;
+    m_bPagesTreeLoad = false;
+    m_bMainXRefLoadedOK = false;
+    m_bAnnotsLoad = false;
+    m_bHaveAcroForm = false;
+    m_bAcroFormLoad = false;
+    m_bPageLoadedOK = false;
+    m_bNeedDownLoadResource = false;
+    m_bLinearizedFormParamLoad = false;
     m_pLinearized = NULL;
     m_pRoot = NULL;
     m_pTrailer = NULL;
@@ -2938,10 +2938,10 @@ CPDF_DataAvail::CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRea
     m_pPageResource = NULL;
     m_pageMapCheckState = NULL;
     m_docStatus = PDF_DATAAVAIL_HEADER;
-    m_parser.m_bOwnFileRead = FALSE;
-    m_bTotalLoadPageTree = FALSE;
-    m_bCurPageDictLoadOK = FALSE;
-    m_bLinearedDataOK = FALSE;
+    m_parser.m_bOwnFileRead = false;
+    m_bTotalLoadPageTree = false;
+    m_bCurPageDictLoadOK = false;
+    m_bLinearedDataOK = false;
     m_pagesLoadState = NULL;
 }
 CPDF_DataAvail::~CPDF_DataAvail()
@@ -2995,10 +2995,10 @@ FX_DWORD CPDF_DataAvail::GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset)
     }
     return 0;
 }
-FX_BOOL CPDF_DataAvail::IsObjectsAvail(CFX_PtrArray& obj_array, FX_BOOL bParsePage, IFX_DownloadHints* pHints, CFX_PtrArray &ret_array)
+bool CPDF_DataAvail::IsObjectsAvail(CFX_PtrArray& obj_array, bool bParsePage, IFX_DownloadHints* pHints, CFX_PtrArray &ret_array)
 {
     if (!obj_array.GetSize()) {
-        return TRUE;
+        return true;
     }
     FX_DWORD count = 0;
     CFX_PtrArray new_obj_array;
@@ -3088,42 +3088,42 @@ FX_BOOL CPDF_DataAvail::IsObjectsAvail(CFX_PtrArray& obj_array, FX_BOOL bParsePa
                 ret_array.Add(pObj);
             }
         }
-        return FALSE;
+        return false;
     }
     obj_array.RemoveAll();
     obj_array.Append(new_obj_array);
-    return IsObjectsAvail(obj_array, FALSE, pHints, ret_array);
+    return IsObjectsAvail(obj_array, false, pHints, ret_array);
 }
-FX_BOOL CPDF_DataAvail::IsDocAvail(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::IsDocAvail(IFX_DownloadHints* pHints)
 {
     if (!m_dwFileLen && m_pFileRead) {
         m_dwFileLen = (FX_DWORD)m_pFileRead->GetSize();
         if (!m_dwFileLen) {
-            return TRUE;
+            return true;
         }
     }
     while (!m_bDocAvail) {
         if (!CheckDocStatus(pHints)) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckAcroFormSubObject(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckAcroFormSubObject(IFX_DownloadHints* pHints)
 {
     if (!m_objs_array.GetSize()) {
         m_objs_array.RemoveAll();
         m_objnum_array.RemoveAll();
         CFX_PtrArray obj_array;
         obj_array.Append(m_arrayAcroforms);
-        FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array);
+        bool bRet = IsObjectsAvail(obj_array, false, pHints, m_objs_array);
         if (bRet) {
             m_objs_array.RemoveAll();
         }
         return bRet;
     }
     CFX_PtrArray new_objs_array;
-    FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
+    bool bRet = IsObjectsAvail(m_objs_array, false, pHints, new_objs_array);
     if (bRet) {
         int32_t iSize = m_arrayAcroforms.GetSize();
         for (int32_t i = 0; i < iSize; ++i) {
@@ -3136,26 +3136,26 @@ FX_BOOL CPDF_DataAvail::CheckAcroFormSubObject(IFX_DownloadHints* pHints)
     }
     return bRet;
 }
-FX_BOOL CPDF_DataAvail::CheckAcroForm(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckAcroForm(IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     m_pAcroForm = GetObject(m_dwAcroFormObjNum, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_PAGETREE;
-        return TRUE;
+        return true;
     }
     if (!m_pAcroForm) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     m_arrayAcroforms.Add(m_pAcroForm);
     m_docStatus = PDF_DATAAVAIL_PAGETREE;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckDocStatus(IFX_DownloadHints *pHints)
+bool CPDF_DataAvail::CheckDocStatus(IFX_DownloadHints *pHints)
 {
     switch (m_docStatus) {
         case PDF_DATAAVAIL_HEADER:
@@ -3195,17 +3195,17 @@ FX_BOOL CPDF_DataAvail::CheckDocStatus(IFX_DownloadHints *pHints)
                 return CheckPage(pHints);
             }
             m_docStatus = PDF_DATAAVAIL_PAGE_LATERLOAD;
-            return TRUE;
+            return true;
         case PDF_DATAAVAIL_ERROR:
             return LoadAllFile(pHints);
         case PDF_DATAAVAIL_PAGE_LATERLOAD:
             m_docStatus = PDF_DATAAVAIL_PAGE;
         default:
-            m_bDocAvail = TRUE;
-            return TRUE;
+            m_bDocAvail = true;
+            return true;
     }
 }
-FX_BOOL	CPDF_DataAvail::CheckPageStatus(IFX_DownloadHints* pHints)
+bool	CPDF_DataAvail::CheckPageStatus(IFX_DownloadHints* pHints)
 {
     switch (m_docStatus) {
         case PDF_DATAAVAIL_PAGETREE:
@@ -3215,36 +3215,36 @@ FX_BOOL	CPDF_DataAvail::CheckPageStatus(IFX_DownloadHints* pHints)
         case PDF_DATAAVAIL_ERROR:
             return LoadAllFile(pHints);
         default:
-            m_bPagesTreeLoad = TRUE;
-            m_bPagesLoad = TRUE;
-            return TRUE;
+            m_bPagesTreeLoad = true;
+            m_bPagesLoad = true;
+            return true;
     }
 }
-FX_BOOL CPDF_DataAvail::LoadAllFile(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::LoadAllFile(IFX_DownloadHints* pHints)
 {
     if (m_pFileAvail->IsDataAvail(0, (FX_DWORD)m_dwFileLen)) {
         m_docStatus = PDF_DATAAVAIL_DONE;
-        return TRUE;
+        return true;
     }
     pHints->AddSegment(0, (FX_DWORD)m_dwFileLen);
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::LoadAllXref(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::LoadAllXref(IFX_DownloadHints* pHints)
 {
     m_parser.m_Syntax.InitParser(m_pFileRead, (FX_DWORD)m_dwHeaderOffset);
-    m_parser.m_bOwnFileRead = FALSE;
+    m_parser.m_bOwnFileRead = false;
     if (!m_parser.LoadAllCrossRefV4(m_dwLastXRefOffset) && !m_parser.LoadAllCrossRefV5(m_dwLastXRefOffset)) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-        return FALSE;
+        return false;
     }
     FXSYS_qsort(m_parser.m_SortedOffset.GetData(), m_parser.m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     m_dwRootObjNum = m_parser.GetRootObjNum();
     m_dwInfoObjNum = m_parser.GetInfoObjNum();
     m_pCurrentParser = &m_parser;
     m_docStatus = PDF_DATAAVAIL_ROOT;
-    return TRUE;
+    return true;
 }
-CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, FX_BOOL *pExistInFile)
+CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, bool *pExistInFile)
 {
     CPDF_Object *pRet         = NULL;
     FX_DWORD    original_size = 0;
@@ -3252,7 +3252,7 @@ CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHint
     CPDF_Parser *pParser      = NULL;
 
     if (pExistInFile) {
-        *pExistInFile = TRUE;
+        *pExistInFile = true;
     }
 
     if (m_pDocument == NULL) {
@@ -3267,7 +3267,7 @@ CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHint
     pdfium::base::CheckedNumeric<FX_DWORD> size = original_size;
     if (size.ValueOrDefault(0) == 0 || offset < 0 || offset >= m_dwFileLen) {
         if (pExistInFile)
-           *pExistInFile = FALSE;
+           *pExistInFile = false;
 
         return NULL;
     }
@@ -3298,15 +3298,15 @@ CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum, IFX_DownloadHints* pHint
     }
 
     if (!pRet && pExistInFile) {
-        *pExistInFile = FALSE;
+        *pExistInFile = false;
     }
 
     return pRet;
 }
 
-FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Object *pInfo = GetObject(m_dwInfoObjNum, pHints, &bExist);
     if (!bExist) {
         if (m_bHaveAcroForm) {
@@ -3314,17 +3314,17 @@ FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints)
         } else {
             m_docStatus = PDF_DATAAVAIL_PAGETREE;
         }
-        return TRUE;
+        return true;
     }
     if (!pInfo) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-            return TRUE;
+            return true;
         }
         if (m_Pos == m_dwFileLen) {
             m_docStatus = PDF_DATAAVAIL_ERROR;
         }
-        return FALSE;
+        return false;
     }
     if (pInfo) {
         pInfo->Release();
@@ -3334,37 +3334,37 @@ FX_BOOL CPDF_DataAvail::CheckInfo(IFX_DownloadHints* pHints)
     } else {
         m_docStatus = PDF_DATAAVAIL_PAGETREE;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckRoot(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckRoot(IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     m_pRoot = GetObject(m_dwRootObjNum, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-        return TRUE;
+        return true;
     }
     if (!m_pRoot) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pDict = m_pRoot->GetDict();
     if (!pDict) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     CPDF_Reference* pRef = (CPDF_Reference*)pDict->GetElement(FX_BSTRC("Pages"));
     if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     m_PagesObjNum = pRef->GetRefObjNum();
     CPDF_Reference* pAcroFormRef = (CPDF_Reference*)m_pRoot->GetDict()->GetElement(FX_BSTRC("AcroForm"));
     if (pAcroFormRef && pAcroFormRef->GetType() == PDFOBJ_REFERENCE) {
-        m_bHaveAcroForm = TRUE;
+        m_bHaveAcroForm = true;
         m_dwAcroFormObjNum = pAcroFormRef->GetRefObjNum();
     }
     if (m_dwInfoObjNum) {
@@ -3376,22 +3376,22 @@ FX_BOOL CPDF_DataAvail::CheckRoot(IFX_DownloadHints* pHints)
             m_docStatus = PDF_DATAAVAIL_PAGETREE;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::PreparePageItem()
+bool CPDF_DataAvail::PreparePageItem()
 {
     CPDF_Dictionary *pRoot = m_pDocument->GetRoot();
     CPDF_Reference* pRef = pRoot ? (CPDF_Reference*)pRoot->GetElement(FX_BSTRC("Pages")) : NULL;
     if (pRef == NULL || pRef->GetType() != PDFOBJ_REFERENCE) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     m_PagesObjNum = pRef->GetRefObjNum();
     m_pCurrentParser = (CPDF_Parser *)m_pDocument->GetParser();
     m_docStatus = PDF_DATAAVAIL_PAGETREE;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::IsFirstCheck(int iPage)
+bool CPDF_DataAvail::IsFirstCheck(int iPage)
 {
     if (NULL == m_pageMapCheckState) {
         m_pageMapCheckState = new CFX_CMapDWordToDWord();
@@ -3399,13 +3399,13 @@ FX_BOOL CPDF_DataAvail::IsFirstCheck(int iPage)
     FX_DWORD dwValue = 0;
     if (!m_pageMapCheckState->Lookup(iPage, dwValue)) {
         m_pageMapCheckState->SetAt(iPage, 1);
-        return TRUE;
+        return true;
     }
     if (dwValue != 0) {
-        return FALSE;
+        return false;
     }
     m_pageMapCheckState->SetAt(iPage, 1);
-    return TRUE;
+    return true;
 }
 void CPDF_DataAvail::ResetFirstCheck(int iPage)
 {
@@ -3418,13 +3418,13 @@ void CPDF_DataAvail::ResetFirstCheck(int iPage)
     }
     m_pageMapCheckState->SetAt(iPage, 0);
 }
-FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints)
 {
     FX_DWORD iPageObjs = m_PageObjList.GetSize();
     CFX_DWordArray UnavailObjList;
     for (FX_DWORD i = 0; i < iPageObjs; ++i) {
         FX_DWORD dwPageObjNum = m_PageObjList.GetAt(i);
-        FX_BOOL bExist = FALSE;
+        bool bExist = false;
         CPDF_Object *pObj = GetObject(dwPageObjNum, pHints, &bExist);
         if (!pObj) {
             if (bExist) {
@@ -3459,7 +3459,7 @@ FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints)
     m_PageObjList.RemoveAll();
     if (UnavailObjList.GetSize()) {
         m_PageObjList.Append(UnavailObjList);
-        return FALSE;
+        return false;
     }
     FX_DWORD iPages = m_PagesArray.GetSize();
     for (FX_DWORD i = 0; i < iPages; i++) {
@@ -3475,7 +3475,7 @@ FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints)
             }
             m_PagesArray.RemoveAll();
             m_docStatus = PDF_DATAAVAIL_ERROR;
-            return FALSE;
+            return false;
         }
         pPages->Release();
     }
@@ -3483,18 +3483,18 @@ FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints)
     if (!m_PageObjList.GetSize()) {
         m_docStatus = PDF_DATAAVAIL_DONE;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages)
+bool CPDF_DataAvail::GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages)
 {
     if (!pParser) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pDict = pPages->GetDict();
     CPDF_Object *pKids = pDict ? pDict->GetElement(FX_BSTRC("Kids")) : NULL;
     if (!pKids) {
-        return TRUE;
+        return true;
     }
     switch (pKids->GetType()) {
         case PDFOBJ_REFERENCE: {
@@ -3514,35 +3514,35 @@ FX_BOOL CPDF_DataAvail::GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages)
             break;
         default:
             m_docStatus = PDF_DATAAVAIL_ERROR;
-            return FALSE;
+            return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckPages(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPages(IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Object *pPages = GetObject(m_PagesObjNum, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-        return TRUE;
+        return true;
     }
     if (!pPages) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (!GetPageKids(m_pCurrentParser, pPages)) {
         pPages->Release();
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     pPages->Release();
     m_docStatus = PDF_DATAAVAIL_PAGE;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckHeader(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckHeader(IFX_DownloadHints* pHints)
 {
     FX_DWORD req_size = 1024;
     if ((FX_FILESIZE)req_size > m_dwFileLen) {
@@ -3555,34 +3555,34 @@ FX_BOOL CPDF_DataAvail::CheckHeader(IFX_DownloadHints* pHints)
             m_docStatus = PDF_DATAAVAIL_FIRSTPAGE;
         } else {
             if (m_docStatus == PDF_DATAAVAIL_ERROR) {
-                return FALSE;
+                return false;
             }
             m_docStatus = PDF_DATAAVAIL_END;
         }
-        return TRUE;
+        return true;
     }
     pHints->AddSegment(0, req_size);
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckFirstPage(IFX_DownloadHints *pHints)
+bool CPDF_DataAvail::CheckFirstPage(IFX_DownloadHints *pHints)
 {
     CPDF_Dictionary* pDict = m_pLinearized->GetDict();
     CPDF_Object *pEndOffSet = pDict ? pDict->GetElement(FX_BSTRC("E")) : NULL;
     if (!pEndOffSet) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     CPDF_Object *pXRefOffset = pDict ? pDict->GetElement(FX_BSTRC("T")) : NULL;
     if (!pXRefOffset) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     CPDF_Object *pFileLen = pDict ? pDict->GetElement(FX_BSTRC("L")) : NULL;
     if (!pFileLen) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
-    FX_BOOL bNeedDownLoad = FALSE;
+    bool bNeedDownLoad = false;
     if (pEndOffSet->GetType() == PDFOBJ_NUMBER) {
         FX_DWORD dwEnd = pEndOffSet->GetInteger();
         dwEnd += 512;
@@ -3593,7 +3593,7 @@ FX_BOOL CPDF_DataAvail::CheckFirstPage(IFX_DownloadHints *pHints)
         int32_t iSize = dwEnd > 1024 ? dwEnd - 1024 : 0;
         if (!m_pFileAvail->IsDataAvail(iStartPos, iSize)) {
             pHints->AddSegment(iStartPos, iSize);
-            bNeedDownLoad = TRUE;
+            bNeedDownLoad = true;
         }
     }
     m_dwLastXRefOffset = 0;
@@ -3619,16 +3619,16 @@ FX_BOOL CPDF_DataAvail::CheckFirstPage(IFX_DownloadHints *pHints)
     }
     if (!bNeedDownLoad && m_docStatus == PDF_DATAAVAIL_FIRSTPAGE_PREPARE) {
         m_docStatus = PDF_DATAAVAIL_DONE;
-        return TRUE;
+        return true;
     }
     m_docStatus = PDF_DATAAVAIL_FIRSTPAGE_PREPARE;
-    return FALSE;
+    return false;
 }
 CPDF_Object	* CPDF_DataAvail::ParseIndirectObjectAt(FX_FILESIZE pos, FX_DWORD objnum)
 {
     FX_FILESIZE SavedPos = m_syntaxParser.SavePos();
     m_syntaxParser.RestorePos(pos);
-    FX_BOOL bIsNumber;
+    bool bIsNumber;
     CFX_ByteString word = m_syntaxParser.GetNextWord(bIsNumber);
     if (!bIsNumber) {
         return NULL;
@@ -3670,21 +3670,21 @@ int32_t CPDF_DataAvail::IsLinearizedPDF()
     }
     return PDF_NOT_LINEARIZED;
 }
-FX_BOOL CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen)
+bool CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen)
 {
-    CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pData, (size_t)dwLen, FALSE));
+    CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pData, (size_t)dwLen, false));
     int32_t offset = GetHeaderOffset(file.Get());
     if (offset == -1) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     m_dwHeaderOffset = offset;
     m_syntaxParser.InitParser(file.Get(), offset);
     m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9);
-    FX_BOOL bNumber = FALSE;
+    bool bNumber = false;
     CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(bNumber);
     if (!bNumber) {
-        return FALSE;
+        return false;
     }
     FX_DWORD objnum = FXSYS_atoi(wordObjNum);
     if (m_pLinearized) {
@@ -3693,58 +3693,58 @@ FX_BOOL CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen)
     }
     m_pLinearized = ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
     if (!m_pLinearized) {
-        return FALSE;
+        return false;
     }
     if (m_pLinearized->GetDict() && m_pLinearized->GetDict()->GetElement(FX_BSTRC("Linearized"))) {
         CPDF_Object *pLen = m_pLinearized->GetDict()->GetElement(FX_BSTRC("L"));
         if (!pLen) {
-            return FALSE;
+            return false;
         }
         if ((FX_FILESIZE)pLen->GetInteger() != m_pFileRead->GetSize()) {
-            return FALSE;
+            return false;
         }
-        m_bLinearized = TRUE;
+        m_bLinearized = true;
         CPDF_Object *pNo = m_pLinearized->GetDict()->GetElement(FX_BSTRC("P"));
         if (pNo && pNo->GetType() == PDFOBJ_NUMBER) {
             m_dwFirstPageNo = pNo->GetInteger();
         }
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckEnd(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckEnd(IFX_DownloadHints* pHints)
 {
     FX_DWORD req_pos = (FX_DWORD)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
     FX_DWORD dwSize = (FX_DWORD)(m_dwFileLen - req_pos);
     if (m_pFileAvail->IsDataAvail(req_pos, dwSize)) {
         uint8_t buffer[1024];
         m_pFileRead->ReadBlock(buffer, req_pos, dwSize);
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(buffer, (size_t)dwSize, FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(buffer, (size_t)dwSize, false));
         m_syntaxParser.InitParser(file.Get(), 0);
         m_syntaxParser.RestorePos(dwSize - 1);
-        if (m_syntaxParser.SearchWord(FX_BSTRC("startxref"), TRUE, FALSE, dwSize)) {
-            FX_BOOL bNumber;
+        if (m_syntaxParser.SearchWord(FX_BSTRC("startxref"), true, false, dwSize)) {
+            bool bNumber;
             m_syntaxParser.GetNextWord(bNumber);
             CFX_ByteString xrefpos_str = m_syntaxParser.GetNextWord(bNumber);
             if (!bNumber) {
                 m_docStatus = PDF_DATAAVAIL_ERROR;
-                return FALSE;
+                return false;
             }
             m_dwXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
             if (!m_dwXRefOffset || m_dwXRefOffset > m_dwFileLen) {
                 m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-                return TRUE;
+                return true;
             }
             m_dwLastXRefOffset = m_dwXRefOffset;
             SetStartOffset(m_dwXRefOffset);
             m_docStatus = PDF_DATAAVAIL_CROSSREF;
-            return TRUE;
+            return true;
         }
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-        return TRUE;
+        return true;
     }
     pHints->AddSegment(req_pos, dwSize);
-    return FALSE;
+    return false;
 }
 int32_t CPDF_DataAvail::CheckCrossRefStream(IFX_DownloadHints* pHints, FX_FILESIZE &xref_offset)
 {
@@ -3755,9 +3755,9 @@ int32_t CPDF_DataAvail::CheckCrossRefStream(IFX_DownloadHints* pHints, FX_FILESI
         CFX_BinaryBuf buf(iSize);
         uint8_t* pBuf = buf.GetBuffer();
         m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize);
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, false));
         m_parser.m_Syntax.InitParser(file.Get(), 0);
-        FX_BOOL bNumber = FALSE;
+        bool bNumber = false;
         CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(bNumber);
         if (!bNumber) {
             return -1;
@@ -3789,18 +3789,18 @@ inline void CPDF_DataAvail::SetStartOffset(FX_FILESIZE dwOffset)
     m_Pos = dwOffset;
 }
 #define MAX_WORD_BUFFER 256
-FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
+bool CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
 {
     m_WordSize = 0;
     uint8_t ch;
     if (!GetNextChar(ch)) {
-        return FALSE;
+        return false;
     }
     uint8_t type = PDF_CharType[ch];
     while (1) {
         while (type == 'W') {
             if (!GetNextChar(ch)) {
-                return FALSE;
+                return false;
             }
             type = PDF_CharType[ch];
         }
@@ -3809,7 +3809,7 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
         }
         while (1) {
             if (!GetNextChar(ch)) {
-                return FALSE;
+                return false;
             }
             if (ch == '\r' || ch == '\n') {
                 break;
@@ -3822,14 +3822,14 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
         if (ch == '/') {
             while (1) {
                 if (!GetNextChar(ch)) {
-                    return FALSE;
+                    return false;
                 }
                 type = PDF_CharType[ch];
                 if (type != 'R' && type != 'N') {
                     m_Pos --;
                     CFX_ByteString ret(m_WordBuffer, m_WordSize);
                     token = ret;
-                    return TRUE;
+                    return true;
                 }
                 if (m_WordSize < MAX_WORD_BUFFER) {
                     m_WordBuffer[m_WordSize++] = ch;
@@ -3837,7 +3837,7 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
             }
         } else if (ch == '<') {
             if (!GetNextChar(ch)) {
-                return FALSE;
+                return false;
             }
             if (ch == '<') {
                 m_WordBuffer[m_WordSize++] = ch;
@@ -3846,7 +3846,7 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
             }
         } else if (ch == '>') {
             if (!GetNextChar(ch)) {
-                return FALSE;
+                return false;
             }
             if (ch == '>') {
                 m_WordBuffer[m_WordSize++] = ch;
@@ -3856,14 +3856,14 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
         }
         CFX_ByteString ret(m_WordBuffer, m_WordSize);
         token = ret;
-        return TRUE;
+        return true;
     }
     while (1) {
         if (m_WordSize < MAX_WORD_BUFFER) {
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (!GetNextChar(ch)) {
-            return FALSE;
+            return false;
         }
         type = PDF_CharType[ch];
         if (type == 'D' || type == 'W') {
@@ -3873,13 +3873,13 @@ FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString &token)
     }
     CFX_ByteString ret(m_WordBuffer, m_WordSize);
     token = ret;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::GetNextChar(uint8_t &ch)
+bool CPDF_DataAvail::GetNextChar(uint8_t &ch)
 {
     FX_FILESIZE pos = m_Pos;
     if (pos >= m_dwFileLen) {
-        return FALSE;
+        return false;
     }
     if (m_bufferOffset >= pos || (FX_FILESIZE)(m_bufferOffset + m_bufferSize) <= pos) {
         FX_FILESIZE read_pos = pos;
@@ -3891,16 +3891,16 @@ FX_BOOL CPDF_DataAvail::GetNextChar(uint8_t &ch)
             read_pos = m_dwFileLen - read_size;
         }
         if (!m_pFileRead->ReadBlock(m_bufferData, read_pos, read_size)) {
-            return FALSE;
+            return false;
         }
         m_bufferOffset = read_pos;
         m_bufferSize = read_size;
     }
     ch = m_bufferData[pos - m_bufferOffset];
     m_Pos ++;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckCrossRefItem(IFX_DownloadHints *pHints)
+bool CPDF_DataAvail::CheckCrossRefItem(IFX_DownloadHints *pHints)
 {
     int32_t iSize = 0;
     CFX_ByteString token;
@@ -3908,16 +3908,16 @@ FX_BOOL CPDF_DataAvail::CheckCrossRefItem(IFX_DownloadHints *pHints)
         if (!GetNextToken(token)) {
             iSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
             pHints->AddSegment(m_Pos, iSize);
-            return FALSE;
+            return false;
         }
         if (token == "trailer") {
             m_dwTrailerOffset = m_Pos;
             m_docStatus = PDF_DATAAVAIL_TRAILER;
-            return TRUE;
+            return true;
         }
     }
 }
-FX_BOOL CPDF_DataAvail::CheckAllCrossRefStream(IFX_DownloadHints *pHints)
+bool CPDF_DataAvail::CheckAllCrossRefStream(IFX_DownloadHints *pHints)
 {
     FX_FILESIZE xref_offset = 0;
     int32_t nRet = CheckCrossRefStream(pHints, xref_offset);
@@ -3928,21 +3928,21 @@ FX_BOOL CPDF_DataAvail::CheckAllCrossRefStream(IFX_DownloadHints *pHints)
             m_dwCurrentXRefSteam = xref_offset;
             m_Pos = xref_offset;
         }
-        return TRUE;
+        return true;
     }
     if (nRet == -1) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckCrossRef(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckCrossRef(IFX_DownloadHints* pHints)
 {
     int32_t iSize = 0;
     CFX_ByteString token;
     if (!GetNextToken(token)) {
         iSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
         pHints->AddSegment(m_Pos, iSize);
-        return FALSE;
+        return false;
     }
     if (token == "xref") {
         m_CrossOffset.InsertAt(0, m_dwXRefOffset);
@@ -3951,28 +3951,28 @@ FX_BOOL CPDF_DataAvail::CheckCrossRef(IFX_DownloadHints* pHints)
                 iSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
                 pHints->AddSegment(m_Pos, iSize);
                 m_docStatus = PDF_DATAAVAIL_CROSSREF_ITEM;
-                return FALSE;
+                return false;
             }
             if (token == "trailer") {
                 m_dwTrailerOffset = m_Pos;
                 m_docStatus = PDF_DATAAVAIL_TRAILER;
-                return TRUE;
+                return true;
             }
         }
     } else {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckTrailerAppend(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckTrailerAppend(IFX_DownloadHints* pHints)
 {
     if (m_Pos < m_dwFileLen) {
         FX_FILESIZE dwAppendPos = m_Pos + m_syntaxParser.SavePos();
         int32_t iSize = (int32_t)(dwAppendPos + 512 > m_dwFileLen ? m_dwFileLen - dwAppendPos : 512);
         if (!m_pFileAvail->IsDataAvail(dwAppendPos, iSize)) {
             pHints->AddSegment(dwAppendPos, iSize);
-            return FALSE;
+            return false;
         }
     }
     if (m_dwPrevXRefOffset) {
@@ -3981,9 +3981,9 @@ FX_BOOL CPDF_DataAvail::CheckTrailerAppend(IFX_DownloadHints* pHints)
     } else {
         m_docStatus = PDF_DATAAVAIL_LOADALLCRSOSSREF;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
 {
     int32_t iTrailerSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
     if (m_pFileAvail->IsDataAvail(m_Pos, iTrailerSize)) {
@@ -3992,21 +3992,21 @@ FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
         uint8_t* pBuf = buf.GetBuffer();
         if (!pBuf) {
             m_docStatus = PDF_DATAAVAIL_ERROR;
-            return FALSE;
+            return false;
         }
         if (!m_pFileRead->ReadBlock(pBuf, m_dwTrailerOffset, iSize)) {
-            return FALSE;
+            return false;
         }
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, false));
         m_syntaxParser.InitParser(file.Get(), 0);
         CPDF_Object *pTrailer = m_syntaxParser.GetObject(NULL, 0, 0, 0);
         if (!pTrailer) {
             m_Pos += m_syntaxParser.SavePos();
             pHints->AddSegment(m_Pos, iTrailerSize);
-            return FALSE;
+            return false;
         }
         if (pTrailer->GetType() != PDFOBJ_DICTIONARY) {
-            return FALSE;
+            return false;
         }
         CPDF_Dictionary *pTrailerDict = pTrailer->GetDict();
         if (pTrailerDict) {
@@ -4014,7 +4014,7 @@ FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
             if (pEncrypt && pEncrypt->GetType() == PDFOBJ_REFERENCE) {
                 m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
                 pTrailer->Release();
-                return TRUE;
+                return true;
             }
         }
         FX_DWORD xrefpos = GetDirectInteger(pTrailer->GetDict(), FX_BSTRC("Prev"));
@@ -4032,60 +4032,60 @@ FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
                     m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND;
                 }
             }
-            return TRUE;
+            return true;
         }
         m_dwPrevXRefOffset = 0;
         m_docStatus = PDF_DATAAVAIL_TRAILER_APPEND;
         pTrailer->Release();
-        return TRUE;
+        return true;
     }
     pHints->AddSegment(m_Pos, iTrailerSize);
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckPage(int32_t iPage, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPage(int32_t iPage, IFX_DownloadHints* pHints)
 {
-    while (TRUE) {
+    while (true) {
         switch (m_docStatus) {
             case PDF_DATAAVAIL_PAGETREE:
                 if (!LoadDocPages(pHints)) {
-                    return FALSE;
+                    return false;
                 }
                 break;
             case PDF_DATAAVAIL_PAGE:
                 if (!LoadDocPage(iPage, pHints)) {
-                    return FALSE;
+                    return false;
                 }
                 break;
             case PDF_DATAAVAIL_ERROR:
                 return LoadAllFile(pHints);
             default:
-                m_bPagesTreeLoad = TRUE;
-                m_bPagesLoad = TRUE;
-                m_bCurPageDictLoadOK = TRUE;
+                m_bPagesTreeLoad = true;
+                m_bPagesLoad = true;
+                m_bCurPageDictLoadOK = true;
                 m_docStatus = PDF_DATAAVAIL_PAGE;
-                return TRUE;
+                return true;
         }
     }
 }
-FX_BOOL	CPDF_DataAvail::CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints)
+bool	CPDF_DataAvail::CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Object *pPages = GetObject(dwPageNo, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     if (!pPages) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_ERROR;
-            return FALSE;
+            return false;
         }
-        return FALSE;
+        return false;
     }
     if (pPages->GetType() != PDFOBJ_ARRAY) {
         pPages->Release();
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     pPageNode->m_type = PDF_PAGENODE_PAGES;
     CPDF_Array* pArray = (CPDF_Array*)pPages;
@@ -4099,33 +4099,33 @@ FX_BOOL	CPDF_DataAvail::CheckArrayPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPa
         pNode->m_dwPageNo = ((CPDF_Reference*)pKid)->GetRefObjNum();
     }
     pPages->Release();
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pPageNode, IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Object *pPage = GetObject(dwPageNo, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     if (!pPage) {
         if (m_docStatus == PDF_DATAAVAIL_ERROR) {
             m_docStatus = PDF_DATAAVAIL_ERROR;
-            return FALSE;
+            return false;
         }
-        return FALSE;
+        return false;
     }
     if (pPage->GetType() == PDFOBJ_ARRAY) {
         pPageNode->m_dwPageNo = dwPageNo;
         pPageNode->m_type = PDF_PAGENODE_ARRAY;
         pPage->Release();
-        return TRUE;
+        return true;
     }
     if (pPage->GetType() != PDFOBJ_DICTIONARY) {
         pPage->Release();
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     pPageNode->m_dwPageNo = dwPageNo;
     CPDF_Dictionary* pDict = pPage->GetDict();
@@ -4135,7 +4135,7 @@ FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pP
         CPDF_Object *pKids = pDict->GetElement(FX_BSTRC("Kids"));
         if (!pKids) {
             m_docStatus = PDF_DATAAVAIL_PAGE;
-            return TRUE;
+            return true;
         }
         switch (pKids->GetType()) {
             case PDFOBJ_REFERENCE: {
@@ -4166,17 +4166,17 @@ FX_BOOL CPDF_DataAvail::CheckUnkownPageNode(FX_DWORD dwPageNo, CPDF_PageNode *pP
     } else {
         pPage->Release();
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     pPage->Release();
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, int32_t &iCount, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, int32_t &iCount, IFX_DownloadHints* pHints)
 {
     int32_t iSize = pageNodes.m_childNode.GetSize();
     if (iSize <= 0 || iPage >= iSize) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     for (int32_t i = 0; i < iSize; ++i) {
         CPDF_PageNode *pNode = (CPDF_PageNode*)pageNodes.m_childNode.GetAt(i);
@@ -4186,7 +4186,7 @@ FX_BOOL CPDF_DataAvail::CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, i
         switch (pNode->m_type) {
             case PDF_PAGENODE_UNKOWN:
                 if (!CheckUnkownPageNode(pNode->m_dwPageNo, pNode, pHints)) {
-                    return FALSE;
+                    return false;
                 }
                 --i;
                 break;
@@ -4198,199 +4198,199 @@ FX_BOOL CPDF_DataAvail::CheckPageNode(CPDF_PageNode &pageNodes, int32_t iPage, i
                 break;
             case PDF_PAGENODE_PAGES:
                 if (!CheckPageNode(*pNode, iPage, iCount, pHints)) {
-                    return FALSE;
+                    return false;
                 }
                 break;
             case PDF_PAGENODE_ARRAY:
                 if (!CheckArrayPageNode(pNode->m_dwPageNo, pNode, pHints)) {
-                    return FALSE;
+                    return false;
                 }
                 --i;
                 break;
         }
         if (iPage == iCount) {
             m_docStatus = PDF_DATAAVAIL_DONE;
-            return TRUE;
+            return true;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::LoadDocPage(int32_t iPage, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::LoadDocPage(int32_t iPage, IFX_DownloadHints* pHints)
 {
     if (m_pDocument->GetPageCount() <= iPage || m_pDocument->m_PageList.GetAt(iPage)) {
         m_docStatus = PDF_DATAAVAIL_DONE;
-        return TRUE;
+        return true;
     }
     if (m_pageNodes.m_type == PDF_PAGENODE_PAGE) {
         if (iPage == 0) {
             m_docStatus = PDF_DATAAVAIL_DONE;
-            return TRUE;
+            return true;
         }
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return TRUE;
+        return true;
     }
     int32_t iCount = -1;
     return CheckPageNode(m_pageNodes, iPage, iCount, pHints);
 }
-FX_BOOL CPDF_DataAvail::CheckPageCount(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPageCount(IFX_DownloadHints* pHints)
 {
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Object *pPages = GetObject(m_PagesObjNum, pHints, &bExist);
     if (!bExist) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     if (!pPages) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pPagesDict = pPages->GetDict();
     if (!pPagesDict) {
         pPages->Release();
         m_docStatus = PDF_DATAAVAIL_ERROR;
-        return FALSE;
+        return false;
     }
     if (!pPagesDict->KeyExist(FX_BSTRC("Kids"))) {
         pPages->Release();
-        return TRUE;
+        return true;
     }
     int count = pPagesDict->GetInteger(FX_BSTRC("Count"));
     if (count > 0) {
         pPages->Release();
-        return TRUE;
+        return true;
     }
     pPages->Release();
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::LoadDocPages(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::LoadDocPages(IFX_DownloadHints* pHints)
 {
     if (!CheckUnkownPageNode(m_PagesObjNum, &m_pageNodes, pHints)) {
-        return FALSE;
+        return false;
     }
     if (CheckPageCount(pHints)) {
         m_docStatus = PDF_DATAAVAIL_PAGE;
-        return TRUE;
+        return true;
     }
-    m_bTotalLoadPageTree = TRUE;
-    return FALSE;
+    m_bTotalLoadPageTree = true;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::LoadPages(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::LoadPages(IFX_DownloadHints* pHints)
 {
     while (!m_bPagesTreeLoad) {
         if (!CheckPageStatus(pHints)) {
-            return FALSE;
+            return false;
         }
     }
     if (m_bPagesLoad) {
-        return TRUE;
+        return true;
     }
     m_pDocument->LoadPages();
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_DataAvail::CheckLinearizedData(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckLinearizedData(IFX_DownloadHints* pHints)
 {
     if (m_bLinearedDataOK) {
-        return TRUE;
+        return true;
     }
 
     if (!m_bMainXRefLoadTried) {
         FX_SAFE_DWORD data_size = m_dwFileLen;
         data_size -= m_dwLastXRefOffset;
         if (!data_size.IsValid()) {
-            return FALSE;
+            return false;
         }
         if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset, data_size.ValueOrDie())) {
             pHints->AddSegment(m_dwLastXRefOffset, data_size.ValueOrDie());
-            return FALSE;
+            return false;
         }
         FX_DWORD dwRet = ((CPDF_Parser *)m_pDocument->GetParser())->LoadLinearizedMainXRefTable();
-        m_bMainXRefLoadTried = TRUE;
+        m_bMainXRefLoadTried = true;
         if (dwRet != PDFPARSE_ERROR_SUCCESS) {
-            return FALSE;
+            return false;
         }
         if (!PreparePageItem()) {
-            return FALSE;
+            return false;
         }
-        m_bMainXRefLoadedOK = TRUE;
-        m_bLinearedDataOK   = TRUE;
+        m_bMainXRefLoadedOK = true;
+        m_bLinearedDataOK   = true;
     }
 
     return m_bLinearedDataOK;
 }
-FX_BOOL CPDF_DataAvail::CheckPageAnnots(int32_t iPage, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckPageAnnots(int32_t iPage, IFX_DownloadHints* pHints)
 {
     if (!m_objs_array.GetSize()) {
         m_objs_array.RemoveAll();
         m_objnum_array.RemoveAll();
         CPDF_Dictionary *pPageDict = m_pDocument->GetPage(iPage);
         if (!pPageDict) {
-            return TRUE;
+            return true;
         }
         CPDF_Object *pAnnots = pPageDict->GetElement(FX_BSTRC("Annots"));
         if (!pAnnots) {
-            return TRUE;
+            return true;
         }
         CFX_PtrArray obj_array;
         obj_array.Add(pAnnots);
-        FX_BOOL bRet = IsObjectsAvail(obj_array, FALSE, pHints, m_objs_array);
+        bool bRet = IsObjectsAvail(obj_array, false, pHints, m_objs_array);
         if (bRet) {
             m_objs_array.RemoveAll();
         }
         return bRet;
     }
     CFX_PtrArray new_objs_array;
-    FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
+    bool bRet = IsObjectsAvail(m_objs_array, false, pHints, new_objs_array);
     m_objs_array.RemoveAll();
     if (!bRet) {
         m_objs_array.Append(new_objs_array);
     }
     return bRet;
 }
-FX_BOOL CPDF_DataAvail::CheckLinearizedFirstPage(int32_t iPage, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckLinearizedFirstPage(int32_t iPage, IFX_DownloadHints* pHints)
 {
     if (!m_bAnnotsLoad) {
         if (!CheckPageAnnots(iPage, pHints)) {
-            return FALSE;
+            return false;
         }
-        m_bAnnotsLoad = TRUE;
+        m_bAnnotsLoad = true;
     }
     if (m_bAnnotsLoad) {
         if (!CheckLinearizedData(pHints))
-            return FALSE;
+            return false;
     }
-    m_bPageLoadedOK = FALSE;
-    return TRUE;
+    m_bPageLoadedOK = false;
+    return true;
 }
-FX_BOOL CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary *pDict)
+bool CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary *pDict)
 {
     CFX_AutoRestorer<int> restorer(&s_CurrentDataAvailRecursionDepth);
     if (++s_CurrentDataAvailRecursionDepth > kMaxDataAvailRecursionDepth) {
-        return FALSE;
+        return false;
     }
     CPDF_Object *pParent = pDict->GetElement("Parent");
     if (!pParent) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary *pParentDict = pParent->GetDict();
     if (!pParentDict) {
-        return FALSE;
+        return false;
     }
     CPDF_Object *pRet = pParentDict->GetElement("Resources");
     if (pRet) {
         m_pPageResource = pRet;
-        return TRUE;
+        return true;
     }
     return HaveResourceAncestor(pParentDict);
 }
-FX_BOOL CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
 {
     if (!m_pDocument) {
-        return FALSE;
+        return false;
     }
     if (IsFirstCheck(iPage)) {
-        m_bCurPageDictLoadOK = FALSE;
-        m_bPageLoadedOK = FALSE;
-        m_bAnnotsLoad = FALSE;
-        m_bNeedDownLoadResource = FALSE;
+        m_bCurPageDictLoadOK = false;
+        m_bPageLoadedOK = false;
+        m_bAnnotsLoad = false;
+        m_bNeedDownLoadResource = false;
         m_objs_array.RemoveAll();
         m_objnum_array.RemoveAll();
     }
@@ -4399,46 +4399,46 @@ FX_BOOL CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
     }
     FX_DWORD dwPageLoad = 0;
     if (m_pagesLoadState->Lookup(iPage, dwPageLoad) && dwPageLoad != 0) {
-        return TRUE;
+        return true;
     }
     if (m_bLinearized) {
         if ((FX_DWORD)iPage == m_dwFirstPageNo) {
-            m_pagesLoadState->SetAt(iPage, TRUE);
-            return TRUE;
+            m_pagesLoadState->SetAt(iPage, true);
+            return true;
         }
         if (!CheckLinearizedData(pHints)) {
-            return FALSE;
+            return false;
         }
         if (m_bMainXRefLoadedOK) {
             if (m_bTotalLoadPageTree) {
                 if (!LoadPages(pHints)) {
-                    return FALSE;
+                    return false;
                 }
             } else {
                 if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
-                    return FALSE;
+                    return false;
                 }
             }
         } else {
             if (!LoadAllFile(pHints)) {
-                return FALSE;
+                return false;
             }
             ((CPDF_Parser *)m_pDocument->GetParser())->RebuildCrossRef();
             ResetFirstCheck(iPage);
-            return TRUE;
+            return true;
         }
     } else {
         if (!m_bTotalLoadPageTree) {
             if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
-                return FALSE;
+                return false;
             }
         }
     }
     if (m_bHaveAcroForm && !m_bAcroFormLoad) {
         if (!CheckAcroFormSubObject(pHints)) {
-            return FALSE;
+            return false;
         }
-        m_bAcroFormLoad = TRUE;
+        m_bAcroFormLoad = true;
     }
     if (!m_bPageLoadedOK) {
         if (!m_objs_array.GetSize()) {
@@ -4447,23 +4447,23 @@ FX_BOOL CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
             m_pPageDict = m_pDocument->GetPage(iPage);
             if (!m_pPageDict) {
                 ResetFirstCheck(iPage);
-                return TRUE;
+                return true;
             }
             CFX_PtrArray obj_array;
             obj_array.Add(m_pPageDict);
-            FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array);
+            bool bRet = IsObjectsAvail(obj_array, true, pHints, m_objs_array);
             if (bRet) {
                 m_objs_array.RemoveAll();
-                m_bPageLoadedOK = TRUE;
+                m_bPageLoadedOK = true;
             } else {
                 return bRet;
             }
         } else {
             CFX_PtrArray new_objs_array;
-            FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
+            bool bRet = IsObjectsAvail(m_objs_array, false, pHints, new_objs_array);
             m_objs_array.RemoveAll();
             if (bRet) {
-                m_bPageLoadedOK = TRUE;
+                m_bPageLoadedOK = true;
             } else {
                 m_objs_array.Append(new_objs_array);
                 return bRet;
@@ -4473,9 +4473,9 @@ FX_BOOL CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
     if (m_bPageLoadedOK) {
         if (!m_bAnnotsLoad) {
             if (!CheckPageAnnots(iPage, pHints)) {
-                return FALSE;
+                return false;
             }
-            m_bAnnotsLoad = TRUE;
+            m_bAnnotsLoad = true;
         }
     }
     if (m_pPageDict && !m_bNeedDownLoadResource) {
@@ -4483,37 +4483,37 @@ FX_BOOL CPDF_DataAvail::IsPageAvail(int32_t iPage, IFX_DownloadHints* pHints)
         if (!m_pPageResource) {
             m_bNeedDownLoadResource = HaveResourceAncestor(m_pPageDict);
         } else {
-            m_bNeedDownLoadResource = TRUE;
+            m_bNeedDownLoadResource = true;
         }
     }
     if (m_bNeedDownLoadResource) {
-        FX_BOOL bRet = CheckResources(pHints);
+        bool bRet = CheckResources(pHints);
         if (!bRet) {
-            return FALSE;
+            return false;
         }
-        m_bNeedDownLoadResource = FALSE;
+        m_bNeedDownLoadResource = false;
     }
-    m_bPageLoadedOK = FALSE;
-    m_bAnnotsLoad = FALSE;
-    m_bCurPageDictLoadOK = FALSE;
+    m_bPageLoadedOK = false;
+    m_bAnnotsLoad = false;
+    m_bCurPageDictLoadOK = false;
     ResetFirstCheck(iPage);
-    m_pagesLoadState->SetAt(iPage, TRUE);
-    return TRUE;
+    m_pagesLoadState->SetAt(iPage, true);
+    return true;
 }
-FX_BOOL CPDF_DataAvail::CheckResources(IFX_DownloadHints* pHints)
+bool CPDF_DataAvail::CheckResources(IFX_DownloadHints* pHints)
 {
     if (!m_objs_array.GetSize()) {
         m_objs_array.RemoveAll();
         CFX_PtrArray obj_array;
         obj_array.Add(m_pPageResource);
-        FX_BOOL bRet = IsObjectsAvail(obj_array, TRUE, pHints, m_objs_array);
+        bool bRet = IsObjectsAvail(obj_array, true, pHints, m_objs_array);
         if (bRet) {
             m_objs_array.RemoveAll();
         }
         return bRet;
     }
     CFX_PtrArray new_objs_array;
-    FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
+    bool bRet = IsObjectsAvail(m_objs_array, false, pHints, new_objs_array);
     m_objs_array.RemoveAll();
     if (!bRet) {
         m_objs_array.Append(new_objs_array);
@@ -4549,10 +4549,10 @@ int32_t CPDF_DataAvail::IsFormAvail(IFX_DownloadHints *pHints)
         if (!m_objs_array.GetSize()) {
             m_objs_array.Add(pAcroForm->GetDict());
         }
-        m_bLinearizedFormParamLoad = TRUE;
+        m_bLinearizedFormParamLoad = true;
     }
     CFX_PtrArray new_objs_array;
-    FX_BOOL bRet = IsObjectsAvail(m_objs_array, FALSE, pHints, new_objs_array);
+    bool bRet = IsObjectsAvail(m_objs_array, false, pHints, new_objs_array);
     m_objs_array.RemoveAll();
     if (!bRet) {
         m_objs_array.Append(new_objs_array);
@@ -4568,12 +4568,12 @@ void CPDF_SortObjNumArray::AddObjNum(FX_DWORD dwObjNum)
     }
     m_number_array.InsertAt(iNext, dwObjNum);
 }
-FX_BOOL CPDF_SortObjNumArray::Find(FX_DWORD dwObjNum)
+bool CPDF_SortObjNumArray::Find(FX_DWORD dwObjNum)
 {
     int32_t iNext = 0;
     return BinarySearch(dwObjNum, iNext);
 }
-FX_BOOL CPDF_SortObjNumArray::BinarySearch(FX_DWORD value, int32_t &iNext)
+bool CPDF_SortObjNumArray::BinarySearch(FX_DWORD value, int32_t &iNext)
 {
     int32_t iLow = 0;
     int32_t iHigh = m_number_array.GetSize() - 1;
@@ -4581,7 +4581,7 @@ FX_BOOL CPDF_SortObjNumArray::BinarySearch(FX_DWORD value, int32_t &iNext)
         int32_t iMid = (iLow + iHigh) / 2;
         if (m_number_array.GetAt(iMid) == value) {
             iNext = iMid;
-            return TRUE;
+            return true;
         }
         if (m_number_array.GetAt(iMid) > value) {
             iHigh = iMid - 1;
@@ -4590,7 +4590,7 @@ FX_BOOL CPDF_SortObjNumArray::BinarySearch(FX_DWORD value, int32_t &iNext)
         }
     }
     iNext = iLow;
-    return FALSE;
+    return false;
 }
 CPDF_PageNode::~CPDF_PageNode()
 {
diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
index 4903312645..76e245ad92 100644
--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_utility.cpp
@@ -195,7 +195,7 @@ CFX_ByteStringC CPDF_SimpleParser::GetWord()
     }
     return CFX_ByteStringC(pStart, dwSize);
 }
-FX_BOOL CPDF_SimpleParser::SearchToken(const CFX_ByteStringC& token)
+bool CPDF_SimpleParser::SearchToken(const CFX_ByteStringC& token)
 {
     int token_len = token.GetLength();
     while (m_dwCurPos < m_dwSize - token_len) {
@@ -205,30 +205,30 @@ FX_BOOL CPDF_SimpleParser::SearchToken(const CFX_ByteStringC& token)
         m_dwCurPos ++;
     }
     if (m_dwCurPos == m_dwSize - token_len) {
-        return FALSE;
+        return false;
     }
     m_dwCurPos += token_len;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_SimpleParser::SkipWord(const CFX_ByteStringC& token)
+bool CPDF_SimpleParser::SkipWord(const CFX_ByteStringC& token)
 {
     while (1) {
         CFX_ByteStringC word = GetWord();
         if (word.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (word == token) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_SimpleParser::FindTagPair(const CFX_ByteStringC& start_token, const CFX_ByteStringC& end_token,
+bool CPDF_SimpleParser::FindTagPair(const CFX_ByteStringC& start_token, const CFX_ByteStringC& end_token,
                                        FX_DWORD& start_pos, FX_DWORD& end_pos)
 {
     if (!start_token.IsEmpty()) {
         if (!SkipWord(start_token)) {
-            return FALSE;
+            return false;
         }
         start_pos = m_dwCurPos;
     }
@@ -236,15 +236,15 @@ FX_BOOL CPDF_SimpleParser::FindTagPair(const CFX_ByteStringC& start_token, const
         end_pos = m_dwCurPos;
         CFX_ByteStringC word = GetWord();
         if (word.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (word == end_token) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_SimpleParser::FindTagParam(const CFX_ByteStringC& token, int nParams)
+bool CPDF_SimpleParser::FindTagParam(const CFX_ByteStringC& token, int nParams)
 {
     nParams ++;
     FX_DWORD* pBuf = FX_Alloc(FX_DWORD, nParams);
@@ -262,7 +262,7 @@ FX_BOOL CPDF_SimpleParser::FindTagParam(const CFX_ByteStringC& token, int nParam
         CFX_ByteStringC word = GetWord();
         if (word.IsEmpty()) {
             FX_Free(pBuf);
-            return FALSE;
+            return false;
         }
         if (word == token) {
             if (buf_count < nParams) {
@@ -270,10 +270,10 @@ FX_BOOL CPDF_SimpleParser::FindTagParam(const CFX_ByteStringC& token, int nParam
             }
             m_dwCurPos = pBuf[buf_index];
             FX_Free(pBuf);
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 static int _hex2dec(char ch)
 {
@@ -368,7 +368,7 @@ CFX_ByteTextBuf& operator << (CFX_ByteTextBuf& buf, const CPDF_Object* pObj)
             break;
         case PDFOBJ_STRING: {
                 CFX_ByteString str = pObj->GetString();
-                FX_BOOL bHex = ((CPDF_String*)pObj)->IsHex();
+                bool bHex = ((CPDF_String*)pObj)->IsHex();
                 buf << PDF_EncodeString(str, bHex);
                 break;
             }
@@ -417,13 +417,13 @@ CFX_ByteTextBuf& operator << (CFX_ByteTextBuf& buf, const CPDF_Object* pObj)
                 CPDF_Stream* p = (CPDF_Stream*)pObj;
                 buf << p->GetDict() << FX_BSTRC("stream\r\n");
                 CPDF_StreamAcc acc;
-                acc.LoadAllData(p, TRUE);
+                acc.LoadAllData(p, true);
                 buf.AppendBlock(acc.GetData(), acc.GetSize());
                 buf << FX_BSTRC("\r\nendstream");
                 break;
             }
         default:
-            ASSERT(FALSE);
+            ASSERT(false);
             break;
     }
     return buf;
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
index f8b59913e4..a70f5bfdf9 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render.cpp
@@ -18,10 +18,10 @@ CPDF_DocRenderData::CPDF_DocRenderData(CPDF_Document* pPDFDoc)
 
 CPDF_DocRenderData::~CPDF_DocRenderData()
 {
-    Clear(TRUE);
+    Clear(true);
 }
 
-void CPDF_DocRenderData::Clear(FX_BOOL bRelease)
+void CPDF_DocRenderData::Clear(bool bRelease)
 {
     for (auto it = m_Type3FaceMap.begin(); it != m_Type3FaceMap.end();) {
         auto curr_it = it++;
@@ -48,7 +48,7 @@ void CPDF_DocRenderData::Clear(FX_BOOL bRelease)
             delete m_pFontCache;
             m_pFontCache = NULL;
         } else {
-            m_pFontCache->FreeCache(FALSE);
+            m_pFontCache->FreeCache(false);
         }
     }
 }
@@ -118,7 +118,7 @@ void CPDF_RenderModule::DestroyDocData(CPDF_DocRenderData* pDocData)
 void CPDF_RenderModule::ClearDocData(CPDF_DocRenderData* p)
 {
     if (p) {
-        p->Clear(FALSE);
+        p->Clear(false);
     }
 }
 void CPDF_RenderModule::DestroyPageCache(CPDF_PageRenderCache* pCache)
@@ -180,19 +180,19 @@ int CPDF_RenderStatus::s_CurrentRecursionDepth = 0;
 CPDF_RenderStatus::CPDF_RenderStatus()
 {
     m_pContext = NULL;
-    m_bStopped = FALSE;
+    m_bStopped = false;
     m_pDevice = NULL;
     m_pCurObj = NULL;
     m_pStopObj = NULL;
     m_HalftoneLimit = 0;
     m_pObjectRenderer = NULL;
-    m_bPrint = FALSE;
+    m_bPrint = false;
     m_Transparency = 0;
     m_DitherBits = 0;
-    m_bDropObjects = FALSE;
-    m_bStdCS = FALSE;
+    m_bDropObjects = false;
+    m_bStdCS = false;
     m_GroupFamily = 0;
-    m_bLoadMask = FALSE;
+    m_bLoadMask = false;
     m_pType3Char = NULL;
     m_T3FillColor = 0;
     m_pFormResource = NULL;
@@ -205,13 +205,13 @@ CPDF_RenderStatus::~CPDF_RenderStatus()
     delete m_pObjectRenderer;
 }
 
-FX_BOOL CPDF_RenderStatus::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice,
+bool CPDF_RenderStatus::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice,
                                       const CFX_AffineMatrix* pDeviceMatrix, const CPDF_PageObject* pStopObj,
                                       const CPDF_RenderStatus* pParentState, const CPDF_GraphicStates* pInitialStates,
-                                      const CPDF_RenderOptions* pOptions, int transparency, FX_BOOL bDropObjects,
-                                      CPDF_Dictionary* pFormResource, FX_BOOL bStdCS, CPDF_Type3Char* pType3Char,
+                                      const CPDF_RenderOptions* pOptions, int transparency, bool bDropObjects,
+                                      CPDF_Dictionary* pFormResource, bool bStdCS, CPDF_Type3Char* pType3Char,
                                       FX_ARGB fill_color, FX_DWORD GroupFamily,
-                                      FX_BOOL bLoadMask)
+                                      bool bLoadMask)
 {
     m_pContext = pContext;
     m_pDevice = pDevice;
@@ -253,7 +253,7 @@ FX_BOOL CPDF_RenderStatus::Initialize(CPDF_RenderContext* pContext, CFX_RenderDe
     }
     m_pObjectRenderer = NULL;
     m_Transparency = transparency;
-    return TRUE;
+    return true;
 }
 void CPDF_RenderStatus::RenderObjectList(const CPDF_PageObjects* pObjs, const CFX_AffineMatrix* pObj2Device)
 {
@@ -267,7 +267,7 @@ void CPDF_RenderStatus::RenderObjectList(const CPDF_PageObjects* pObjs, const CF
         index ++;
         CPDF_PageObject* pCurObj = pObjs->GetNextObject(pos);
         if (pCurObj == m_pStopObj) {
-            m_bStopped = TRUE;
+            m_bStopped = true;
             return;
         }
         if (!pCurObj) {
@@ -301,42 +301,42 @@ void CPDF_RenderStatus::RenderSingleObject(const CPDF_PageObject* pObj, const CF
     }
     ProcessObjectNoClip(pObj, pObj2Device);
 }
-FX_BOOL CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause)
+bool CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause)
 {
     if (m_pObjectRenderer) {
         if (m_pObjectRenderer->Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         if (!m_pObjectRenderer->m_Result) {
             DrawObjWithBackground(pObj, pObj2Device);
         }
         delete m_pObjectRenderer;
         m_pObjectRenderer = NULL;
-        return FALSE;
+        return false;
     }
     m_pCurObj = pObj;
     if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull())
         if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
-            return FALSE;
+            return false;
         }
     ProcessClipPath(pObj->m_ClipPath, pObj2Device);
     if (ProcessTransparency(pObj, pObj2Device)) {
-        return FALSE;
+        return false;
     }
     if (pObj->m_Type == PDFPAGE_IMAGE) {
         m_pObjectRenderer = IPDF_ObjectRenderer::Create(pObj->m_Type);
-        if (!m_pObjectRenderer->Start(this, pObj, pObj2Device, FALSE)) {
+        if (!m_pObjectRenderer->Start(this, pObj, pObj2Device, false)) {
             if (!m_pObjectRenderer->m_Result) {
                 DrawObjWithBackground(pObj, pObj2Device);
             }
             delete m_pObjectRenderer;
             m_pObjectRenderer = NULL;
-            return FALSE;
+            return false;
         }
         return ContinueSingleObject(pObj, pObj2Device, pPause);
     }
     ProcessObjectNoClip(pObj, pObj2Device);
-    return FALSE;
+    return false;
 }
 IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type)
 {
@@ -345,7 +345,7 @@ IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type)
     }
     return new CPDF_ImageRenderer;
 }
-FX_BOOL CPDF_RenderStatus::GetObjectClippedRect(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bLogical, FX_RECT &rect) const
+bool CPDF_RenderStatus::GetObjectClippedRect(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, bool bLogical, FX_RECT &rect) const
 {
     rect = pObj->GetBBox(pObj2Device);
     FX_RECT rtClip = m_pDevice->GetClipBox();
@@ -370,7 +370,7 @@ void CPDF_RenderStatus::DitherObjectArea(const CPDF_PageObject* pObj, const CFX_
         return;
     }
     FX_RECT rect;
-    if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
+    if (GetObjectClippedRect(pObj, pObj2Device, false, rect)) {
         return;
     }
     if (m_DitherBits == 2) {
@@ -386,7 +386,7 @@ void CPDF_RenderStatus::DitherObjectArea(const CPDF_PageObject* pObj, const CFX_
 }
 void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
-    FX_BOOL bRet = FALSE;
+    bool bRet = false;
     switch (pObj->m_Type) {
         case PDFPAGE_TEXT:
             bRet = ProcessText((CPDF_TextObject*)pObj, pObj2Device, NULL);
@@ -408,9 +408,9 @@ void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj, const C
         DrawObjWithBackground(pObj, pObj2Device);
     }
 }
-FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
-    FX_BOOL bRet = FALSE;
+    bool bRet = false;
     switch (pObj->m_Type) {
         case PDFPAGE_PATH:
             bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
@@ -433,7 +433,7 @@ void CPDF_RenderStatus::GetScaledMatrix(CFX_Matrix &matrix) const
 void CPDF_RenderStatus::DrawObjWithBackground(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device)
 {
     FX_RECT rect;
-    if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
+    if (GetObjectClippedRect(pObj, pObj2Device, false, rect)) {
         return;
     }
     int res = 300;
@@ -459,11 +459,11 @@ void CPDF_RenderStatus::DrawObjWithBackground(const CPDF_PageObject* pObj, const
     status.RenderSingleObject(pObj, &matrix);
     buffer.OutputToDevice();
 }
-FX_BOOL CPDF_RenderStatus::ProcessForm(CPDF_FormObject* pFormObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessForm(CPDF_FormObject* pFormObj, const CFX_AffineMatrix* pObj2Device)
 {
     CPDF_Dictionary* pOC = pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("OC"));
     if (pOC && m_Options.m_pOCContext && !m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
-        return TRUE;
+        return true;
     }
     CFX_AffineMatrix matrix = pFormObj->m_FormMatrix;
     matrix.Concat(*pObj2Device);
@@ -473,15 +473,15 @@ FX_BOOL CPDF_RenderStatus::ProcessForm(CPDF_FormObject* pFormObj, const CFX_Affi
     }
     CPDF_RenderStatus status;
     status.Initialize(m_pContext, m_pDevice, NULL, m_pStopObj,
-                      this, pFormObj, &m_Options, m_Transparency, m_bDropObjects, pResources, FALSE);
+                      this, pFormObj, &m_Options, m_Transparency, m_bDropObjects, pResources, false);
     status.m_curBlend = m_curBlend;
     m_pDevice->SaveState();
     status.RenderObjectList(pFormObj->m_pForm, &matrix);
     m_bStopped = status.m_bStopped;
     m_pDevice->RestoreState();
-    return TRUE;
+    return true;
 }
-FX_BOOL IsAvailableMatrix(const CFX_AffineMatrix& matrix)
+bool IsAvailableMatrix(const CFX_AffineMatrix& matrix)
 {
     if (matrix.a == 0 || matrix.d == 0) {
         return matrix.b != 0 && matrix.c != 0;
@@ -489,15 +489,15 @@ FX_BOOL IsAvailableMatrix(const CFX_AffineMatrix& matrix)
     if (matrix.b == 0 || matrix.c == 0) {
         return matrix.a != 0 && matrix.d != 0;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device)
 {
     int FillType = pPathObj->m_FillType;
-    FX_BOOL bStroke = pPathObj->m_bStroke;
+    bool bStroke = pPathObj->m_bStroke;
     ProcessPathPattern(pPathObj, pObj2Device, FillType, bStroke);
     if (FillType == 0 && !bStroke) {
-        return TRUE;
+        return true;
     }
     FX_DWORD fill_argb = 0;
     if (FillType) {
@@ -510,7 +510,7 @@ FX_BOOL CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj, const CFX_Affi
     CFX_AffineMatrix path_matrix = pPathObj->m_Matrix;
     path_matrix.Concat(*pObj2Device);
     if (!IsAvailableMatrix(path_matrix)) {
-        return TRUE;
+        return true;
     }
     if (FillType && (m_Options.m_Flags & RENDER_RECT_AA)) {
         FillType |= FXFILL_RECT_AA;
@@ -546,7 +546,7 @@ CPDF_TransferFunc* CPDF_RenderStatus::GetTransferFunc(CPDF_Object* pObj) const
     }
     return pDocCache->GetTransferFunc(pObj);
 }
-FX_ARGB CPDF_RenderStatus::GetFillArgb(const CPDF_PageObject* pObj, FX_BOOL bType3) const
+FX_ARGB CPDF_RenderStatus::GetFillArgb(const CPDF_PageObject* pObj, bool bType3) const
 {
     CPDF_ColorStateData* pColorData = (CPDF_ColorStateData*)(const CPDF_ColorStateData*)pObj->m_ColorState;
     if (m_pType3Char && !bType3 && (!m_pType3Char->m_bColored || (m_pType3Char->m_bColored && (!pColorData || pColorData->m_FillColor.IsNull())))) {
@@ -612,7 +612,7 @@ void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath, const CFX_Affine
         if (m_LastClipPath.IsNull()) {
             return;
         }
-        m_pDevice->RestoreState(TRUE);
+        m_pDevice->RestoreState(true);
         m_LastClipPath.SetNull();
         return;
     }
@@ -620,7 +620,7 @@ void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath, const CFX_Affine
         return;
     }
     m_LastClipPath = ClipPath;
-    m_pDevice->RestoreState(TRUE);
+    m_pDevice->RestoreState(true);
     int nClipPath = ClipPath.GetPathCount();
     int i;
     for (i = 0; i < nClipPath; i++) {
@@ -690,7 +690,7 @@ void CPDF_RenderStatus::DrawClipPath(CPDF_ClipPath ClipPath, const CFX_AffineMat
         m_pDevice->DrawPath(pPathData, pObj2Device, &stroke_state, 0, 0xffff0000, fill_mode);
     }
 }
-FX_BOOL CPDF_RenderStatus::SelectClipPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke)
+bool CPDF_RenderStatus::SelectClipPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, bool bStroke)
 {
     CFX_AffineMatrix path_matrix = pPathObj->m_Matrix;
     path_matrix.Concat(*pObj2Device);
@@ -707,12 +707,12 @@ FX_BOOL CPDF_RenderStatus::SelectClipPath(CPDF_PathObject* pPathObj, const CFX_A
     }
     return m_pDevice->SetClip_PathFill(pPathObj->m_Path, &path_matrix, fill_mode);
 }
-FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device)
 {
     const CPDF_GeneralStateData* pGeneralState = pPageObj->m_GeneralState;
     int blend_type = pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
     if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
-        return TRUE;
+        return true;
     }
     CPDF_Dictionary* pSMaskDict = pGeneralState ? (CPDF_Dictionary*)pGeneralState->m_pSoftMask : NULL;
     if (pSMaskDict) {
@@ -724,7 +724,7 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
     CPDF_Dictionary* pFormResource = NULL;
     FX_FLOAT group_alpha = 1.0f;
     int Transparency = m_Transparency;
-    FX_BOOL bGroupTransparent = FALSE;
+    bool bGroupTransparent = false;
     if (pPageObj->m_Type == PDFPAGE_FORM) {
         CPDF_FormObject* pFormObj = (CPDF_FormObject*)pPageObj;
         const CPDF_GeneralStateData *pStateData = pFormObj->m_GeneralState.GetObject();
@@ -732,15 +732,15 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
             group_alpha = pStateData->m_FillAlpha;
         }
         Transparency = pFormObj->m_pForm->m_Transparency;
-        bGroupTransparent = Transparency & PDFTRANS_ISOLATED ? TRUE : FALSE;
+        bGroupTransparent = Transparency & PDFTRANS_ISOLATED ? true : false;
         if (pFormObj->m_pForm->m_pFormDict) {
             pFormResource = pFormObj->m_pForm->m_pFormDict->GetDict("Resources");
         }
     }
-    FX_BOOL bTextClip = FALSE;
+    bool bTextClip = false;
     if (pPageObj->m_ClipPath.NotNull() && pPageObj->m_ClipPath.GetTextCount() &&
             m_pDevice->GetDeviceClass() == FXDC_DISPLAY && !(m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)) {
-        bTextClip = TRUE;
+        bTextClip = true;
     }
     if ((m_Options.m_Flags & RENDER_OVERPRINT) && pPageObj->m_Type == PDFPAGE_IMAGE && pGeneralState && pGeneralState->m_FillOP && pGeneralState->m_StrokeOP) {
         CPDF_Document* pDocument = NULL;
@@ -763,11 +763,11 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
         }
     }
     if (pSMaskDict == NULL && group_alpha == 1.0f && blend_type == FXDIB_BLEND_NORMAL && !bTextClip && !bGroupTransparent) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL isolated = Transparency & PDFTRANS_ISOLATED;
+    bool isolated = Transparency & PDFTRANS_ISOLATED;
     if (m_bPrint) {
-        FX_BOOL bRet = FALSE;
+        bool bRet = false;
         int rendCaps = m_pDevice->GetRenderCaps();
         if (!((Transparency & PDFTRANS_ISOLATED) || pSMaskDict || bTextClip) && (rendCaps & FXRC_BLEND_MODE)) {
             int oldBlend = m_curBlend;
@@ -778,12 +778,12 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
         if (!bRet) {
             DrawObjWithBackground(pPageObj, pObj2Device);
         }
-        return TRUE;
+        return true;
     }
     FX_RECT rect = pPageObj->GetBBox(pObj2Device);
     rect.Intersect(m_pDevice->GetClipBox());
     if (rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     CFX_Matrix deviceCTM = m_pDevice->GetCTM();
     FX_FLOAT scaleX = FXSYS_fabs(deviceCTM.a);
@@ -795,12 +795,12 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
     if (!isolated && (m_pDevice->GetRenderCaps() & FXRC_GET_BITS)) {
         oriDevice = new CFX_DIBitmap;
         if (!m_pDevice->CreateCompatibleBitmap(oriDevice, width, height)) {
-            return TRUE;
+            return true;
         }
         m_pDevice->GetDIBits(oriDevice, rect.left, rect.top);
     }
     if (!bitmap_device.Create(width, height, FXDIB_Argb, 0, oriDevice)) {
-        return TRUE;
+        return true;
     }
     CFX_DIBitmap* bitmap = bitmap_device.GetBitmap();
     bitmap->Clear(0);
@@ -812,7 +812,7 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
         pTextMask = new CFX_DIBitmap;
         if (!pTextMask->Create(width, height, FXDIB_8bppMask)) {
             delete pTextMask;
-            return TRUE;
+            return true;
         }
         pTextMask->Clear(0);
         CFX_FxgeDevice text_device;
@@ -831,7 +831,7 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
     }
     CPDF_RenderStatus bitmap_render;
     bitmap_render.Initialize(m_pContext, &bitmap_device, NULL,
-                             m_pStopObj, NULL, NULL, &m_Options, 0, m_bDropObjects, pFormResource, TRUE);
+                             m_pStopObj, NULL, NULL, &m_Options, 0, m_bDropObjects, pFormResource, true);
     bitmap_render.ProcessObjectNoClip(pPageObj, &new_matrix);
     m_bStopped = bitmap_render.m_bStopped;
     if (pSMaskDict) {
@@ -858,10 +858,10 @@ FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
     }
     CompositeDIBitmap(bitmap, rect.left, rect.top, 0, 255, blend_type, Transparency);
     delete oriDevice;
-    return TRUE;
+    return true;
 }
 CFX_DIBitmap* CPDF_RenderStatus::GetBackdrop(const CPDF_PageObject* pObj, const FX_RECT& rect, int& left, int& top,
-        FX_BOOL bBackAlphaRequired)
+        bool bBackAlphaRequired)
 {
     FX_RECT bbox = rect;
     bbox.Intersect(m_pDevice->GetClipBox());
@@ -882,7 +882,7 @@ CFX_DIBitmap* CPDF_RenderStatus::GetBackdrop(const CPDF_PageObject* pObj, const
         delete pBackdrop;
         return NULL;
     }
-    FX_BOOL bNeedDraw;
+    bool bNeedDraw;
     if (pBackdrop->HasAlpha()) {
         bNeedDraw = !(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT);
     } else {
@@ -911,7 +911,7 @@ void CPDF_RenderContext::GetBackground(CFX_DIBitmap* pBuffer, const CPDF_PageObj
     device.FillRect(&rect, 0xffffffff);
     Render(&device, pObj, pOptions, pFinalMatrix);
 }
-CPDF_GraphicStates* CPDF_RenderStatus::CloneObjStates(const CPDF_GraphicStates* pSrcStates, FX_BOOL bStroke)
+CPDF_GraphicStates* CPDF_RenderStatus::CloneObjStates(const CPDF_GraphicStates* pSrcStates, bool bStroke)
 {
     if (!pSrcStates) {
         return NULL;
@@ -932,14 +932,14 @@ CPDF_RenderContext::CPDF_RenderContext()
 {
 }
 void CPDF_RenderContext::Create(CPDF_Document* pDoc, CPDF_PageRenderCache* pPageCache,
-                                CPDF_Dictionary* pPageResources, FX_BOOL bFirstLayer)
+                                CPDF_Dictionary* pPageResources, bool bFirstLayer)
 {
     m_pDocument = pDoc;
     m_pPageResources = pPageResources;
     m_pPageCache = pPageCache;
     m_bFirstLayer = bFirstLayer;
 }
-void CPDF_RenderContext::Create(CPDF_Page* pPage, FX_BOOL bFirstLayer)
+void CPDF_RenderContext::Create(CPDF_Page* pPage, bool bFirstLayer)
 {
     m_pDocument = pPage->m_pDocument;
     m_pPageResources = pPage->m_pPageResources;
@@ -954,7 +954,7 @@ void CPDF_RenderContext::Clear()
     m_pDocument = NULL;
     m_pPageResources = NULL;
     m_pPageCache = NULL;
-    m_bFirstLayer = TRUE;
+    m_bFirstLayer = true;
     m_ContentList.RemoveAll();
 }
 void CPDF_RenderContext::AppendObjectList(CPDF_PageObjects* pObjs, const CFX_AffineMatrix* pObject2Device)
@@ -984,7 +984,7 @@ void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice, const CPDF_PageObject
             FinalMatrix.Concat(*pLastMatrix);
             CPDF_RenderStatus status;
             status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL, pOptions,
-                              pItem->m_pObjectList->m_Transparency, FALSE, NULL);
+                              pItem->m_pObjectList->m_Transparency, false, NULL);
             status.RenderObjectList(pItem->m_pObjectList, &FinalMatrix);
             if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
                 m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
@@ -996,7 +996,7 @@ void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice, const CPDF_PageObject
         } else {
             CPDF_RenderStatus status;
             status.Initialize(this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
-                              pItem->m_pObjectList->m_Transparency, FALSE, NULL);
+                              pItem->m_pObjectList->m_Transparency, false, NULL);
             status.RenderObjectList(pItem->m_pObjectList, &pItem->m_Matrix);
             if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
                 m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
@@ -1090,7 +1090,7 @@ void CPDF_ProgressiveRenderer::Continue(IFX_Pause* pPause)
             m_pRenderStatus.reset(new CPDF_RenderStatus());
             m_pRenderStatus->Initialize(
                 m_pContext, m_pDevice, NULL, NULL, NULL, NULL, m_pOptions,
-                pItem->m_pObjectList->m_Transparency, FALSE, NULL);
+                pItem->m_pObjectList->m_Transparency, false, NULL);
             m_pDevice->SaveState();
             m_ClipRect = m_pDevice->GetClipBox();
             CFX_AffineMatrix device2object;
@@ -1171,10 +1171,10 @@ CPDF_TransferFunc* CPDF_DocRenderData::GetTransferFunc(CPDF_Object* pObj)
     }
 
     CPDF_Function* pFuncs[3] = { nullptr, nullptr, nullptr };
-    FX_BOOL bUniTransfer = TRUE;
-    FX_BOOL bIdentity = TRUE;
+    bool bUniTransfer = true;
+    bool bIdentity = true;
     if (pObj->GetType() == PDFOBJ_ARRAY) {
-        bUniTransfer = FALSE;
+        bUniTransfer = false;
         CPDF_Array* pArray = (CPDF_Array*)pObj;
         if (pArray->GetCount() < 3)
             return nullptr;
@@ -1208,7 +1208,7 @@ CPDF_TransferFunc* CPDF_DocRenderData::GetTransferFunc(CPDF_Object* pObj)
                 pFuncs[0]->Call(&input, 1, output, noutput);
             int o = FXSYS_round(output[0] * 255);
             if (o != v)
-                bIdentity = FALSE;
+                bIdentity = false;
             for (int i = 0; i < 3; ++i) {
                 pTransfer->m_Samples[i * 256 + v] = o;
             }
@@ -1218,7 +1218,7 @@ CPDF_TransferFunc* CPDF_DocRenderData::GetTransferFunc(CPDF_Object* pObj)
                     pFuncs[i]->Call(&input, 1, output, noutput);
                     int o = FXSYS_round(output[0] * 255);
                     if (o != v)
-                        bIdentity = FALSE;
+                        bIdentity = false;
                     pTransfer->m_Samples[i * 256 + v] = o;
                 } else {
                     pTransfer->m_Samples[i * 256 + v] = v;
@@ -1258,7 +1258,7 @@ CPDF_DeviceBuffer::~CPDF_DeviceBuffer()
 {
     delete m_pBitmap;
 }
-FX_BOOL CPDF_DeviceBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
+bool CPDF_DeviceBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
                                       const CPDF_PageObject* pObj, int max_dpi)
 {
     m_pDevice = pDevice;
@@ -1289,7 +1289,7 @@ FX_BOOL CPDF_DeviceBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDe
     FX_RECT bitmap_rect = rect.GetOutterRect();
     m_pBitmap = new CFX_DIBitmap;
     m_pBitmap->Create(bitmap_rect.Width(), bitmap_rect.Height(), FXDIB_Argb);
-    return TRUE;
+    return true;
 }
 void CPDF_DeviceBuffer::OutputToDevice()
 {
@@ -1316,13 +1316,13 @@ CPDF_ScaledRenderBuffer::~CPDF_ScaledRenderBuffer()
     delete m_pBitmapDevice;
 }
 #define _FPDFAPI_IMAGESIZE_LIMIT_	(30 * 1024 * 1024)
-FX_BOOL CPDF_ScaledRenderBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
+bool CPDF_ScaledRenderBuffer::Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
         const CPDF_PageObject* pObj, const CPDF_RenderOptions *pOptions, int max_dpi)
 {
     FXSYS_assert(pRect != NULL);
     m_pDevice = pDevice;
     if (m_pDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_GET_BITS) {
-        return TRUE;
+        return true;
     }
     m_pContext = pContext;
     m_Rect = *pRect;
@@ -1357,7 +1357,7 @@ FX_BOOL CPDF_ScaledRenderBuffer::Initialize(CPDF_RenderContext* pContext, CFX_Re
         iHeight = bitmap_rect.Height();
         iPitch = (iWidth * bpp + 31) / 32 * 4;
         if (iWidth * iHeight < 1) {
-            return FALSE;
+            return false;
         }
         if (iPitch * iHeight <= _FPDFAPI_IMAGESIZE_LIMIT_ &&
                 m_pBitmapDevice->Create(iWidth, iHeight, dibFormat)) {
@@ -1366,7 +1366,7 @@ FX_BOOL CPDF_ScaledRenderBuffer::Initialize(CPDF_RenderContext* pContext, CFX_Re
         m_Matrix.Scale(0.5f, 0.5f);
     }
     m_pContext->GetBackground(m_pBitmapDevice->GetBitmap(), m_pObject, pOptions, &m_Matrix);
-    return TRUE;
+    return true;
 }
 void CPDF_ScaledRenderBuffer::OutputToDevice()
 {
@@ -1374,7 +1374,7 @@ void CPDF_ScaledRenderBuffer::OutputToDevice()
         m_pDevice->StretchDIBits(m_pBitmapDevice->GetBitmap(), m_Rect.left, m_Rect.top, m_Rect.Width(), m_Rect.Height());
     }
 }
-FX_BOOL IPDF_OCContext::CheckObjectVisible(const CPDF_PageObject* pObj)
+bool IPDF_OCContext::CheckObjectVisible(const CPDF_PageObject* pObj)
 {
     const CPDF_ContentMarkData* pData = pObj->m_ContentMark;
     int nItems = pData->CountItems();
@@ -1383,9 +1383,9 @@ FX_BOOL IPDF_OCContext::CheckObjectVisible(const CPDF_PageObject* pObj)
         if (item.GetName() == FX_BSTRC("OC") && item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict) {
             CPDF_Dictionary* pOCG = (CPDF_Dictionary*)item.GetParam();
             if (!CheckOCGVisible(pOCG)) {
-                return FALSE;
+                return false;
             }
         }
     }
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_cache.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_cache.cpp
index cdbecd65ea..d9767b4817 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_cache.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_cache.cpp
@@ -108,16 +108,16 @@ FX_DWORD CPDF_PageRenderCache::GetCachedSize(CPDF_Stream* pStream) const
     return pImageCache->EstimateSize();
 }
 void CPDF_PageRenderCache::GetCachedBitmap(CPDF_Stream* pStream, CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor,
-        FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
+        bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus,
         int32_t downsampleWidth, int32_t downsampleHeight)
 {
     CPDF_ImageCache* pImageCache;
-    FX_BOOL bFind = m_ImageCaches.Lookup(pStream, (void*&)pImageCache);
+    bool bFind = m_ImageCaches.Lookup(pStream, (void*&)pImageCache);
     if (!bFind) {
         pImageCache = new CPDF_ImageCache(m_pPage->m_pDocument, pStream);
     }
     m_nTimeCount ++;
-    FX_BOOL bCached = pImageCache->GetCachedBitmap(pBitmap, pMask, MatteColor, m_pPage->m_pPageResources, bStdCS, GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
+    bool bCached = pImageCache->GetCachedBitmap(pBitmap, pMask, MatteColor, m_pPage->m_pPageResources, bStdCS, GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
     if (!bFind) {
         m_ImageCaches.SetAt(pStream, pImageCache);
     }
@@ -125,7 +125,7 @@ void CPDF_PageRenderCache::GetCachedBitmap(CPDF_Stream* pStream, CFX_DIBSource*&
         m_nCacheSize += pImageCache->EstimateSize();
     }
 }
-FX_BOOL	CPDF_PageRenderCache::StartGetCachedBitmap(CPDF_Stream* pStream, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t downsampleWidth, int32_t downsampleHeight)
+bool	CPDF_PageRenderCache::StartGetCachedBitmap(CPDF_Stream* pStream, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t downsampleWidth, int32_t downsampleHeight)
 {
     m_bCurFindCache = m_ImageCaches.Lookup(pStream, (void*&)m_pCurImageCache);
     if (!m_bCurFindCache) {
@@ -133,7 +133,7 @@ FX_BOOL	CPDF_PageRenderCache::StartGetCachedBitmap(CPDF_Stream* pStream, FX_BOOL
     }
     int ret = m_pCurImageCache->StartGetCachedBitmap(pRenderStatus->m_pFormResource, m_pPage->m_pPageResources, bStdCS, GroupFamily, bLoadMask, pRenderStatus, downsampleWidth, downsampleHeight);
     if (ret == 2) {
-        return TRUE;
+        return true;
     }
     m_nTimeCount ++;
     if (!m_bCurFindCache) {
@@ -142,13 +142,13 @@ FX_BOOL	CPDF_PageRenderCache::StartGetCachedBitmap(CPDF_Stream* pStream, FX_BOOL
     if (!ret) {
         m_nCacheSize += m_pCurImageCache->EstimateSize();
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_PageRenderCache::Continue(IFX_Pause* pPause)
+bool	CPDF_PageRenderCache::Continue(IFX_Pause* pPause)
 {
     int ret = m_pCurImageCache->Continue(pPause);
     if (ret == 2) {
-        return TRUE;
+        return true;
     }
     m_nTimeCount ++;
     if (!m_bCurFindCache) {
@@ -157,7 +157,7 @@ FX_BOOL	CPDF_PageRenderCache::Continue(IFX_Pause* pPause)
     if (!ret) {
         m_nCacheSize += m_pCurImageCache->EstimateSize();
     }
-    return FALSE;
+    return false;
 }
 void CPDF_PageRenderCache::ResetBitmap(CPDF_Stream* pStream, const CFX_DIBitmap* pBitmap)
 {
@@ -222,18 +222,18 @@ static FX_DWORD FPDF_ImageCache_EstimateImageSize(const CFX_DIBSource* pDIB)
 {
     return pDIB && pDIB->GetBuffer() ? (FX_DWORD)pDIB->GetHeight() * pDIB->GetPitch() + (FX_DWORD)pDIB->GetPaletteSize() * 4 : 0;
 }
-FX_BOOL CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
-        FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
+bool CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
+        bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus,
         int32_t downsampleWidth, int32_t downsampleHeight)
 {
     if (m_pCachedBitmap) {
         pBitmap = m_pCachedBitmap;
         pMask = m_pCachedMask;
         MatteColor = m_MatteColor;
-        return TRUE;
+        return true;
     }
     if (!pRenderStatus) {
-        return FALSE;
+        return false;
     }
     CPDF_RenderContext*pContext = pRenderStatus->GetContext();
     CPDF_PageRenderCache* pPageRenderCache = pContext->m_pPageCache;
@@ -243,7 +243,7 @@ FX_BOOL CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*
     if (!pSrc->Load(m_pDocument, m_pStream, &pMaskSrc, &MatteColor, pRenderStatus->m_pFormResource, pPageResources, bStdCS, GroupFamily, bLoadMask)) {
         delete pSrc;
         pBitmap = NULL;
-        return FALSE;
+        return false;
     }
     m_MatteColor = MatteColor;
     if (pSrc->GetPitch() * pSrc->GetHeight() < FPDF_HUGE_IMAGE_SIZE) {
@@ -260,7 +260,7 @@ FX_BOOL CPDF_ImageCache::GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*
     pBitmap = m_pCachedBitmap;
     pMask = m_pCachedMask;
     CalcSize();
-    return FALSE;
+    return false;
 }
 CFX_DIBSource* CPDF_ImageCache::DetachBitmap()
 {
@@ -274,8 +274,8 @@ CFX_DIBSource* CPDF_ImageCache::DetachMask()
     m_pCurMask = NULL;
     return pDIBSource;
 }
-int	CPDF_ImageCache::StartGetCachedBitmap(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, FX_BOOL bStdCS,
-        FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus,
+int	CPDF_ImageCache::StartGetCachedBitmap(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, bool bStdCS,
+        FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus,
         int32_t downsampleWidth, int32_t downsampleHeight)
 {
     if (m_pCachedBitmap) {
@@ -288,7 +288,7 @@ int	CPDF_ImageCache::StartGetCachedBitmap(CPDF_Dictionary* pFormResources, CPDF_
     }
     m_pRenderStatus = pRenderStatus;
     m_pCurBitmap = new CPDF_DIBSource;
-    int ret = ((CPDF_DIBSource*)m_pCurBitmap)->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResources, pPageResources, bStdCS, GroupFamily, bLoadMask);
+    int ret = ((CPDF_DIBSource*)m_pCurBitmap)->StartLoadDIBSource(m_pDocument, m_pStream, true, pFormResources, pPageResources, bStdCS, GroupFamily, bLoadMask);
     if (ret == 2) {
         return ret;
     }
@@ -347,7 +347,7 @@ void CPDF_Document::ClearRenderFont()
     if (m_pDocRender) {
         CFX_FontCache* pCache = m_pDocRender->GetFontCache();
         if (pCache) {
-            pCache->FreeCache(FALSE);
+            pCache->FreeCache(false);
         }
     }
 }
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
index fa9325a4d2..258ad111fa 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_image.cpp
@@ -13,7 +13,7 @@
 #include "../fpdf_page/pageint.h"
 #include "render_int.h"
 
-FX_BOOL CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pObj2Device)
 {
     CPDF_ImageRenderer render;
     if (render.Start(this, pImageObj, pObj2Device, m_bStdCS, m_curBlend)) {
@@ -27,8 +27,8 @@ void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, int left, int
     if (pDIBitmap == NULL) {
         return;
     }
-    FX_BOOL bIsolated = Transparency & PDFTRANS_ISOLATED;
-    FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
+    bool bIsolated = Transparency & PDFTRANS_ISOLATED;
+    bool bGroup = Transparency & PDFTRANS_GROUP;
     if (blend_mode == FXDIB_BLEND_NORMAL) {
         if (!pDIBitmap->IsAlphaMask()) {
             if (bitmap_alpha < 255) {
@@ -47,8 +47,8 @@ void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, int left, int
             }
         }
     }
-    FX_BOOL bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects;
-    FX_BOOL bGetBackGround = ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) ||
+    bool bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects;
+    bool bGetBackGround = ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) ||
                              (!(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT) && (m_pDevice->GetRenderCaps()
                                      & FXRC_GET_BITS) && !bBackAlphaRequired);
     if (bGetBackGround) {
@@ -61,9 +61,9 @@ void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, int left, int
             FX_RECT rect(left, top, left + pDIBitmap->GetWidth(), top + pDIBitmap->GetHeight());
             rect.Intersect(m_pDevice->GetClipBox());
             CFX_DIBitmap* pClone = NULL;
-            FX_BOOL bClone = FALSE;
+            bool bClone = false;
             if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
-                bClone = TRUE;
+                bClone = true;
                 pClone = m_pDevice->GetBackDrop()->Clone(&rect);
                 CFX_DIBitmap *pForeBitmap = m_pDevice->GetBitmap();
                 pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(), pForeBitmap, rect.left, rect.top);
@@ -118,7 +118,7 @@ FX_COLORREF CPDF_TransferFunc::TranslateColor(FX_COLORREF rgb)
     return FXSYS_RGB(m_Samples[FXSYS_GetRValue(rgb)], m_Samples[256 + FXSYS_GetGValue(rgb)],
                      m_Samples[512 + FXSYS_GetBValue(rgb)]);
 }
-CFX_DIBSource* CPDF_TransferFunc::TranslateImage(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
+CFX_DIBSource* CPDF_TransferFunc::TranslateImage(const CFX_DIBSource* pSrc, bool bAutoDropSrc)
 {
     CPDF_DIBTransferFunc* pDest = new CPDF_DIBTransferFunc(this);
     pDest->LoadSrc(pSrc, bAutoDropSrc);
@@ -144,7 +144,7 @@ CPDF_DIBTransferFunc::CPDF_DIBTransferFunc(const CPDF_TransferFunc* pTransferFun
 void CPDF_DIBTransferFunc::TranslateScanline(uint8_t* dest_buf, const uint8_t* src_buf) const
 {
     int i;
-    FX_BOOL bSkip = FALSE;
+    bool bSkip = false;
     switch (m_pSrc->GetFormat()) {
         case FXDIB_1bppRgb: {
                 int r0 = m_RampR[0], g0 = m_RampG[0], b0 = m_RampB[0];
@@ -213,7 +213,7 @@ void CPDF_DIBTransferFunc::TranslateScanline(uint8_t* dest_buf, const uint8_t* s
             }
             break;
         case FXDIB_Rgb32:
-            bSkip = TRUE;
+            bSkip = true;
         case FXDIB_Argb:
             for (i = 0; i < m_Width; i ++) {
                 *dest_buf++ = m_RampB[*(src_buf++)];
@@ -266,31 +266,31 @@ void CPDF_DIBTransferFunc::TranslateDownSamples(uint8_t* dest_buf, const uint8_t
             }
     }
 }
-static FX_BOOL _IsSupported(CPDF_ColorSpace* pCS)
+static bool _IsSupported(CPDF_ColorSpace* pCS)
 {
     if (pCS->GetFamily() == PDFCS_DEVICERGB || pCS->GetFamily() == PDFCS_DEVICEGRAY ||
             pCS->GetFamily() == PDFCS_DEVICECMYK || pCS->GetFamily() == PDFCS_CALGRAY ||
             pCS->GetFamily() == PDFCS_CALRGB) {
-        return TRUE;
+        return true;
     }
     if (pCS->GetFamily() == PDFCS_INDEXED && _IsSupported(pCS->GetBaseCS())) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 CPDF_ImageRenderer::CPDF_ImageRenderer()
 {
     m_pRenderStatus = NULL;
     m_pImageObject = NULL;
-    m_Result = TRUE;
+    m_Result = true;
     m_Status = 0;
     m_pQuickStretcher = NULL;
     m_pTransformer = NULL;
     m_DeviceHandle = NULL;
     m_LoadHandle = NULL;
     m_pClone = NULL;
-    m_bStdCS = FALSE;
-    m_bPatternColor = FALSE;
+    m_bStdCS = false;
+    m_bPatternColor = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
     m_pPattern = NULL;
     m_pObj2Device = NULL;
@@ -305,7 +305,7 @@ CPDF_ImageRenderer::~CPDF_ImageRenderer()
     delete (CPDF_ProgressiveImageLoaderHandle*)m_LoadHandle;
     delete m_pClone;
 }
-FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource()
+bool CPDF_ImageRenderer::StartLoadDIBSource()
 {
     CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
     FX_RECT image_rect = image_rect_f.GetOutterRect();
@@ -321,16 +321,16 @@ FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource()
                                 m_pRenderStatus->m_GroupFamily, m_pRenderStatus->m_bLoadMask, m_pRenderStatus, dest_width, dest_height)) {
         if (m_LoadHandle != NULL) {
             m_Status = 4;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource()
+bool CPDF_ImageRenderer::StartRenderDIBSource()
 {
     if (m_Loader.m_pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     m_BitmapAlpha = 255;
     const CPDF_GeneralStateData* pGeneralState = m_pImageObject->m_GeneralState;
@@ -350,18 +350,18 @@ FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource()
             if (m_Loader.m_bCached && m_Loader.m_pMask) {
                 m_Loader.m_pMask = m_Loader.m_pMask->Clone();
             }
-            m_Loader.m_bCached = FALSE;
+            m_Loader.m_bCached = false;
         }
     }
     m_FillArgb = 0;
-    m_bPatternColor = FALSE;
+    m_bPatternColor = false;
     m_pPattern = NULL;
     if (m_pDIBSource->IsAlphaMask()) {
         CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
         if (pColor && pColor->IsPattern()) {
             m_pPattern = pColor->GetPattern();
             if (m_pPattern != NULL) {
-                m_bPatternColor = TRUE;
+                m_bPatternColor = true;
             }
         }
         m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject);
@@ -430,7 +430,7 @@ FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource()
     }
     return StartDIBSource();
 }
-FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStdCS, int blendType)
+bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, bool bStdCS, int blendType)
 {
     m_pRenderStatus = pStatus;
     m_bStdCS = bStdCS;
@@ -439,17 +439,17 @@ FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CPDF_PageObj
     m_pObj2Device = pObj2Device;
     CPDF_Dictionary* pOC = m_pImageObject->m_pImage->GetOC();
     if (pOC && m_pRenderStatus->m_Options.m_pOCContext && !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
-        return FALSE;
+        return false;
     }
     m_ImageMatrix = m_pImageObject->m_Matrix;
     m_ImageMatrix.Concat(*pObj2Device);
     if (StartLoadDIBSource()) {
-        return TRUE;
+        return true;
     }
     return StartRenderDIBSource();
 }
-FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CFX_DIBSource* pDIBSource, FX_ARGB bitmap_argb,
-                                  int bitmap_alpha, const CFX_AffineMatrix* pImage2Device, FX_DWORD flags, FX_BOOL bStdCS, int blendType)
+bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CFX_DIBSource* pDIBSource, FX_ARGB bitmap_argb,
+                                  int bitmap_alpha, const CFX_AffineMatrix* pImage2Device, FX_DWORD flags, bool bStdCS, int blendType)
 {
     m_pRenderStatus = pStatus;
     m_pDIBSource = pDIBSource;
@@ -461,16 +461,16 @@ FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, const CFX_DIBSourc
     m_BlendType = blendType;
     return StartDIBSource();
 }
-FX_BOOL	CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device)
+bool	CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device)
 {
     if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-        m_Result = FALSE;
-        return FALSE;
+        m_Result = false;
+        return false;
     }
     FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
     rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
     if (rect.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CFX_AffineMatrix new_matrix = m_ImageMatrix;
     new_matrix.TranslateI(-rect.left, -rect.top);
@@ -478,32 +478,32 @@ FX_BOOL	CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device)
     int height = rect.Height();
     CFX_FxgeDevice bitmap_device1;
     if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32)) {
-        return TRUE;
+        return true;
     }
     bitmap_device1.GetBitmap()->Clear(0xffffff);
     {
         CPDF_RenderStatus bitmap_render;
         bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, NULL, NULL,
-                                 NULL, NULL, &m_pRenderStatus->m_Options, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
+                                 NULL, NULL, &m_pRenderStatus->m_Options, 0, m_pRenderStatus->m_bDropObjects, NULL, true);
         CFX_Matrix patternDevice = *pObj2Device;
         patternDevice.Translate((FX_FLOAT) - rect.left, (FX_FLOAT) - rect.top);
         if(m_pPattern->m_PatternType == PATTERN_TILING) {
-            bitmap_render.DrawTilingPattern((CPDF_TilingPattern*)m_pPattern, m_pImageObject, &patternDevice, FALSE);
+            bitmap_render.DrawTilingPattern((CPDF_TilingPattern*)m_pPattern, m_pImageObject, &patternDevice, false);
         } else {
-            bitmap_render.DrawShadingPattern((CPDF_ShadingPattern*)m_pPattern, m_pImageObject, &patternDevice, FALSE);
+            bitmap_render.DrawShadingPattern((CPDF_ShadingPattern*)m_pPattern, m_pImageObject, &patternDevice, false);
         }
     }
     {
         CFX_FxgeDevice bitmap_device2;
         if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb)) {
-            return TRUE;
+            return true;
         }
         bitmap_device2.GetBitmap()->Clear(0);
         CPDF_RenderStatus bitmap_render;
         bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, NULL, NULL,
-                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
+                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, true);
         CPDF_ImageRenderer image_render;
-        if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255, &new_matrix, m_Flags, TRUE)) {
+        if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255, &new_matrix, m_Flags, true)) {
             image_render.Continue(NULL);
         }
         if (m_Loader.m_MatteColor != 0xffffffff) {
@@ -549,18 +549,18 @@ FX_BOOL	CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device)
         bitmap_device1.GetBitmap()->MultiplyAlpha(255);
     }
     m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageRenderer::DrawMaskedImage()
+bool CPDF_ImageRenderer::DrawMaskedImage()
 {
     if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-        m_Result = FALSE;
-        return FALSE;
+        m_Result = false;
+        return false;
     }
     FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
     rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
     if (rect.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CFX_AffineMatrix new_matrix = m_ImageMatrix;
     new_matrix.TranslateI(-rect.left, -rect.top);
@@ -568,29 +568,29 @@ FX_BOOL CPDF_ImageRenderer::DrawMaskedImage()
     int height = rect.Height();
     CFX_FxgeDevice bitmap_device1;
     if (!bitmap_device1.Create(width, height, FXDIB_Rgb32)) {
-        return TRUE;
+        return true;
     }
     bitmap_device1.GetBitmap()->Clear(0xffffff);
     {
         CPDF_RenderStatus bitmap_render;
         bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, NULL, NULL,
-                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
+                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, true);
         CPDF_ImageRenderer image_render;
-        if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix, m_Flags, TRUE)) {
+        if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix, m_Flags, true)) {
             image_render.Continue(NULL);
         }
     }
     {
         CFX_FxgeDevice bitmap_device2;
         if (!bitmap_device2.Create(width, height, FXDIB_8bppRgb)) {
-            return TRUE;
+            return true;
         }
         bitmap_device2.GetBitmap()->Clear(0);
         CPDF_RenderStatus bitmap_render;
         bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, NULL, NULL,
-                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, TRUE);
+                                 NULL, NULL, NULL, 0, m_pRenderStatus->m_bDropObjects, NULL, true);
         CPDF_ImageRenderer image_render;
-        if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255, &new_matrix, m_Flags, TRUE)) {
+        if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255, &new_matrix, m_Flags, true)) {
             image_render.Continue(NULL);
         }
         if (m_Loader.m_MatteColor != 0xffffffff) {
@@ -638,9 +638,9 @@ FX_BOOL CPDF_ImageRenderer::DrawMaskedImage()
         }
     }
     m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageRenderer::StartDIBSource()
+bool CPDF_ImageRenderer::StartDIBSource()
 {
     if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) {
         int image_size = m_pDIBSource->GetBPP() / 8 * m_pDIBSource->GetWidth() * m_pDIBSource->GetHeight();
@@ -652,9 +652,9 @@ FX_BOOL CPDF_ImageRenderer::StartDIBSource()
             &m_ImageMatrix, m_Flags, m_DeviceHandle, 0, NULL, m_BlendType)) {
         if (m_DeviceHandle != NULL) {
             m_Status = 3;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
     FX_RECT image_rect = image_rect_f.GetOutterRect();
@@ -663,15 +663,15 @@ FX_BOOL CPDF_ImageRenderer::StartDIBSource()
     if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
             (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0) ) {
         if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-            m_Result = FALSE;
-            return FALSE;
+            m_Result = false;
+            return false;
         }
         FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
         clip_box.Intersect(image_rect);
         m_Status = 2;
         m_pTransformer = new CFX_ImageTransformer;
         m_pTransformer->Start(m_pDIBSource, &m_ImageMatrix, m_Flags, &clip_box);
-        return TRUE;
+        return true;
     }
     if (m_ImageMatrix.a < 0) {
         dest_width = -dest_width;
@@ -685,7 +685,7 @@ FX_BOOL CPDF_ImageRenderer::StartDIBSource()
     if (m_pDIBSource->IsOpaqueImage() && m_BitmapAlpha == 255) {
         if (m_pRenderStatus->m_pDevice->StretchDIBits(m_pDIBSource, dest_left, dest_top,
                 dest_width, dest_height, m_Flags, NULL, m_BlendType)) {
-            return FALSE;
+            return false;
         }
     }
     if (m_pDIBSource->IsAlphaMask()) {
@@ -693,12 +693,12 @@ FX_BOOL CPDF_ImageRenderer::StartDIBSource()
             m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
         }
         if (m_pRenderStatus->m_pDevice->StretchBitMask(m_pDIBSource, dest_left, dest_top, dest_width, dest_height, m_FillArgb, m_Flags)) {
-            return FALSE;
+            return false;
         }
     }
     if (m_pRenderStatus->m_bPrint && !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
-        m_Result = FALSE;
-        return TRUE;
+        m_Result = false;
+        return true;
     }
     FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
     FX_RECT dest_rect = clip_box;
@@ -708,13 +708,13 @@ FX_BOOL CPDF_ImageRenderer::StartDIBSource()
     CFX_DIBitmap* pStretched = m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip);
     if (pStretched) {
         m_pRenderStatus->CompositeDIBitmap(pStretched, dest_rect.left, dest_rect.top, m_FillArgb,
-                                           m_BitmapAlpha, m_BlendType, FALSE);
+                                           m_BitmapAlpha, m_BlendType, false);
         delete pStretched;
         pStretched = NULL;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha()
+bool CPDF_ImageRenderer::StartBitmapAlpha()
 {
     if (m_pDIBSource->IsOpaqueImage()) {
         CFX_PathData path;
@@ -728,7 +728,7 @@ FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha()
             int left, top;
             CFX_DIBitmap* pTransformed = pAlphaMask->TransformTo(&m_ImageMatrix, left, top);
             if (pTransformed == NULL) {
-                return TRUE;
+                return true;
             }
             m_pRenderStatus->m_pDevice->SetBitMask(pTransformed, left, top, ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
             delete pTransformed;
@@ -746,13 +746,13 @@ FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha()
             delete pAlphaMask;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause)
+bool CPDF_ImageRenderer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
         if (m_pQuickStretcher->Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         if (m_pQuickStretcher->m_pBitmap->IsAlphaMask())
             m_pRenderStatus->m_pDevice->SetBitMask(m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
@@ -760,15 +760,15 @@ FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause)
         else
             m_pRenderStatus->m_pDevice->SetDIBits(m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
                                                   m_pQuickStretcher->m_ResultTop, m_BlendType);
-        return FALSE;
+        return false;
     }
     if (m_Status == 2) {
         if (m_pTransformer->Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         if (pBitmap->IsAlphaMask()) {
             if (m_BitmapAlpha != 255) {
@@ -784,20 +784,20 @@ FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause)
                        m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop, m_BlendType);
         }
         delete pBitmap;
-        return FALSE;
+        return false;
     }
     if (m_Status == 3) {
         return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
     }
     if (m_Status == 4) {
         if (m_Loader.Continue(m_LoadHandle, pPause)) {
-            return TRUE;
+            return true;
         }
         if (StartRenderDIBSource()) {
             return Continue(pPause);
         }
     }
-    return FALSE;
+    return false;
 }
 CPDF_QuickStretcher::CPDF_QuickStretcher()
 {
@@ -815,10 +815,10 @@ CPDF_QuickStretcher::~CPDF_QuickStretcher()
 }
 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, const CPDF_Dictionary* pParams);
-FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix* pImage2Device, const FX_RECT* pClipBox)
+bool CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix* pImage2Device, const FX_RECT* pClipBox)
 {
     if (FXSYS_fabs(pImage2Device->a) < FXSYS_fabs(pImage2Device->b) * 10 && FXSYS_fabs(pImage2Device->d) < FXSYS_fabs(pImage2Device->c) * 10) {
-        return FALSE;
+        return false;
     }
     CFX_FloatRect image_rect_f = pImage2Device->GetUnitRect();
     FX_RECT image_rect = image_rect_f.GetOutterRect();
@@ -829,7 +829,7 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
     FX_RECT result_rect = *pClipBox;
     result_rect.Intersect(image_rect);
     if (result_rect.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     m_ResultWidth = result_rect.Width();
     m_ResultHeight = result_rect.Height();
@@ -839,10 +839,10 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
     m_ClipTop = result_rect.top - image_rect.top;
     CPDF_Dictionary* pDict = pImageObj->m_pImage->GetDict();
     if (pDict->GetInteger(FX_BSTRC("BitsPerComponent")) != 8) {
-        return FALSE;
+        return false;
     }
     if (pDict->KeyExist(FX_BSTRC("SMask")) || pDict->KeyExist(FX_BSTRC("Mask"))) {
-        return FALSE;
+        return false;
     }
     m_SrcWidth = pDict->GetInteger(FX_BSTRC("Width"));
     m_SrcHeight = pDict->GetInteger(FX_BSTRC("Height"));
@@ -850,14 +850,14 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
     m_Bpp = 3;
     CPDF_Object* pCSObj = pDict->GetElementValue(FX_BSTRC("ColorSpace"));
     if (pCSObj == NULL) {
-        return FALSE;
+        return false;
     }
     m_pCS = CPDF_ColorSpace::Load(pImageObj->m_pImage->GetDocument(), pCSObj);
     if (m_pCS == NULL) {
-        return FALSE;
+        return false;
     }
     if (!_IsSupported(m_pCS)) {
-        return FALSE;
+        return false;
     }
     m_Bpp = m_pCS->CountComponents();
     if (m_pCS->sRGB()) {
@@ -865,7 +865,7 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
         m_pCS = NULL;
     }
     CPDF_Stream* pStream = pImageObj->m_pImage->GetStream();
-    m_StreamAcc.LoadAllData(pStream, FALSE, m_SrcWidth * m_SrcHeight * m_Bpp, TRUE);
+    m_StreamAcc.LoadAllData(pStream, false, m_SrcWidth * m_SrcHeight * m_Bpp, true);
     m_pDecoder = NULL;
     if (!m_StreamAcc.GetImageDecoder().IsEmpty()) {
         if (m_StreamAcc.GetImageDecoder() == FX_BSTRC("DCTDecode")) {
@@ -878,7 +878,7 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
                              m_StreamAcc.GetData(), m_StreamAcc.GetSize(), m_SrcWidth, m_SrcHeight, m_Bpp, 8,
                              m_StreamAcc.GetImageParam());
         } else {
-            return FALSE;
+            return false;
         }
         m_pDecoder->DownScale(m_DestWidth, m_DestHeight);
     }
@@ -889,9 +889,9 @@ FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix
     m_pBitmap->Create(m_ResultWidth, m_ResultHeight, FXDIB_Rgb);
 #endif
     m_LineIndex = 0;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_QuickStretcher::Continue(IFX_Pause* pPause)
+bool CPDF_QuickStretcher::Continue(IFX_Pause* pPause)
 {
     uint8_t* result_buf = m_pBitmap->GetBuffer();
     int src_width = m_pDecoder ? m_pDecoder->GetWidth() : m_SrcWidth;
@@ -945,10 +945,10 @@ FX_BOOL CPDF_QuickStretcher::Continue(IFX_Pause* pPause)
         }
         m_LineIndex ++;
         if (pPause && pPause->NeedToPauseNow()) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
         FX_RECT* pClipRect, const CFX_AffineMatrix* pMatrix)
@@ -959,7 +959,7 @@ CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
     CFX_DIBitmap* pMask = NULL;
     int width = pClipRect->right - pClipRect->left;
     int height = pClipRect->bottom - pClipRect->top;
-    FX_BOOL bLuminosity = FALSE;
+    bool bLuminosity = false;
     bLuminosity = pSMaskDict->GetConstString(FX_BSTRC("S")) != FX_BSTRC("Alpha");
     CPDF_Stream* pGroup = pSMaskDict->GetStream(FX_BSTRC("G"));
     if (pGroup == NULL) {
@@ -1032,7 +1032,7 @@ CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
     options.m_ColorMode = bLuminosity ? RENDER_COLOR_NORMAL : RENDER_COLOR_ALPHA;
     CPDF_RenderStatus status;
     status.Initialize(m_pContext, &bitmap_device, NULL, NULL, NULL, NULL,
-                      &options, 0, m_bDropObjects, pFormResource, TRUE, NULL, 0, pCS ? pCS->GetFamily() : 0, bLuminosity);
+                      &options, 0, m_bDropObjects, pFormResource, true, NULL, 0, pCS ? pCS->GetFamily() : 0, bLuminosity);
     status.RenderObjectList(&form, &matrix);
     pMask = new CFX_DIBitmap;
     if (!pMask->Create(width, height, FXDIB_8bppMask)) {
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
index 7d17e78e24..0861048eb7 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp
@@ -105,7 +105,7 @@ class JpxBitMapContext
 
 }  // namespace
 
-CFX_DIBSource* CPDF_Image::LoadDIBSource(CFX_DIBSource** ppMask, FX_DWORD* pMatteColor, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask) const
+CFX_DIBSource* CPDF_Image::LoadDIBSource(CFX_DIBSource** ppMask, FX_DWORD* pMatteColor, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask) const
 {
     CPDF_DIBSource* pSource = new CPDF_DIBSource;
     if (pSource->Load(m_pDocument, m_pStream, (CPDF_DIBSource**)ppMask, pMatteColor, NULL, NULL, bStdCS, GroupFamily, bLoadMask)) {
@@ -126,36 +126,36 @@ CFX_DIBSource* CPDF_Image::DetachMask()
     m_pMask = NULL;
     return pBitmap;
 }
-FX_BOOL CPDF_Image::StartLoadDIBSource(CPDF_Dictionary* pFormResource, CPDF_Dictionary* pPageResource, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
+bool CPDF_Image::StartLoadDIBSource(CPDF_Dictionary* pFormResource, CPDF_Dictionary* pPageResource, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask)
 {
     m_pDIBSource = new CPDF_DIBSource;
-    int ret = ((CPDF_DIBSource*)m_pDIBSource)->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResource, pPageResource, bStdCS, GroupFamily, bLoadMask);
+    int ret = ((CPDF_DIBSource*)m_pDIBSource)->StartLoadDIBSource(m_pDocument, m_pStream, true, pFormResource, pPageResource, bStdCS, GroupFamily, bLoadMask);
     if (ret == 2) {
-        return TRUE;
+        return true;
     }
     if (!ret) {
         delete m_pDIBSource;
         m_pDIBSource = NULL;
-        return FALSE;
+        return false;
     }
     m_pMask = ((CPDF_DIBSource*)m_pDIBSource)->DetachMask();
     m_MatteColor = ((CPDF_DIBSource*)m_pDIBSource)->m_MatteColor;
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_Image::Continue(IFX_Pause* pPause)
+bool CPDF_Image::Continue(IFX_Pause* pPause)
 {
     int ret = ((CPDF_DIBSource*)m_pDIBSource)->ContinueLoadDIBSource(pPause);
     if (ret == 2) {
-        return TRUE;
+        return true;
     }
     if (!ret) {
         delete m_pDIBSource;
         m_pDIBSource = NULL;
-        return FALSE;
+        return false;
     }
     m_pMask = ((CPDF_DIBSource*)m_pDIBSource)->DetachMask();
     m_MatteColor = ((CPDF_DIBSource*)m_pDIBSource)->m_MatteColor;
-    return FALSE;
+    return false;
 }
 CPDF_DIBSource::CPDF_DIBSource()
 {
@@ -165,26 +165,26 @@ CPDF_DIBSource::CPDF_DIBSource()
     m_bpp = 0;
     m_Width = m_Height = 0;
     m_pColorSpace = NULL;
-    m_bDefaultDecode = TRUE;
-    m_bImageMask = FALSE;
-    m_bDoBpcCheck = TRUE;
+    m_bDefaultDecode = true;
+    m_bImageMask = false;
+    m_bDoBpcCheck = true;
     m_pPalette = NULL;
     m_pCompData = NULL;
-    m_bColorKey = FALSE;
+    m_bColorKey = false;
     m_pMaskedLine = m_pLineBuf = NULL;
     m_pDecoder = NULL;
     m_nComponents = 0;
     m_bpc = 0;
-    m_bLoadMask = FALSE;
+    m_bLoadMask = false;
     m_Family = 0;
     m_pMask = NULL;
     m_MatteColor = 0;
     m_pJbig2Context = NULL;
     m_pGlobalStream = NULL;
-    m_bStdCS = FALSE;
+    m_bStdCS = false;
     m_pMaskStream = NULL;
     m_Status = 0;
-    m_bHasMask = FALSE;
+    m_bHasMask = false;
 }
 CPDF_DIBSource::~CPDF_DIBSource()
 {
@@ -220,43 +220,43 @@ void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const
         delete pBitmap;
     }
 }
-FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CPDF_DIBSource** ppMask,
-                             FX_DWORD* pMatteColor, CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
+bool CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CPDF_DIBSource** ppMask,
+                             FX_DWORD* pMatteColor, CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask)
 {
     if (pStream == NULL) {
-        return FALSE;
+        return false;
     }
     m_pDocument = pDoc;
     m_pDict = pStream->GetDict();
     if (m_pDict == NULL) {
-        return FALSE;
+        return false;
     }
     m_pStream = pStream;
     m_Width = m_pDict->GetInteger(FX_BSTRC("Width"));
     m_Height = m_pDict->GetInteger(FX_BSTRC("Height"));
     if (m_Width <= 0 || m_Height <= 0 || m_Width > 0x01ffff || m_Height > 0x01ffff) {
-        return FALSE;
+        return false;
     }
     m_GroupFamily = GroupFamily;
     m_bLoadMask = bLoadMask;
     if (!LoadColorInfo(m_pStream->GetObjNum() != 0 ? NULL : pFormResources, pPageResources)) {
-        return FALSE;
+        return false;
     }
     if (m_bDoBpcCheck && (m_bpc == 0 || m_nComponents == 0)) {
-        return FALSE;
+        return false;
     }
     FX_SAFE_DWORD src_pitch =
         CalculatePitch8(m_bpc, m_nComponents, m_Width, m_Height);
     if (!src_pitch.IsValid()) {
-        return FALSE;
+        return false;
     }
     m_pStreamAcc = new CPDF_StreamAcc;
-    m_pStreamAcc->LoadAllData(pStream, FALSE, src_pitch.ValueOrDie(), TRUE);
+    m_pStreamAcc->LoadAllData(pStream, false, src_pitch.ValueOrDie(), true);
     if (m_pStreamAcc->GetSize() == 0 || m_pStreamAcc->GetData() == NULL) {
-        return FALSE;
+        return false;
     }
     if (!CreateDecoder()) {
-        return FALSE;
+        return false;
     }
     if (m_bImageMask) {
         m_bpp = 1;
@@ -272,11 +272,11 @@ FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CP
     }
     FX_SAFE_DWORD pitch = CalculatePitch32(m_bpp, m_Width);
     if (!pitch.IsValid()) {
-        return FALSE;
+        return false;
     }
     m_pLineBuf = FX_Alloc(uint8_t, pitch.ValueOrDie());
     if (m_pColorSpace && bStdCS) {
-        m_pColorSpace->EnableStdConversion(TRUE);
+        m_pColorSpace->EnableStdConversion(true);
     }
     LoadPalette();
     if (m_bColorKey) {
@@ -284,7 +284,7 @@ FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CP
         m_AlphaFlag = 2;
         pitch = CalculatePitch32(m_bpp, m_Width);
         if (!pitch.IsValid()) {
-            return FALSE;
+            return false;
         }
         m_pMaskedLine = FX_Alloc(uint8_t, pitch.ValueOrDie());
     }
@@ -293,9 +293,9 @@ FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CP
         *ppMask = LoadMask(*pMatteColor);
     }
     if (m_pColorSpace && bStdCS) {
-        m_pColorSpace->EnableStdConversion(FALSE);
+        m_pColorSpace->EnableStdConversion(false);
     }
-    return TRUE;
+    return true;
 }
 int	CPDF_DIBSource::ContinueToLoadMask()
 {
@@ -320,7 +320,7 @@ int	CPDF_DIBSource::ContinueToLoadMask()
     }
     m_pLineBuf = FX_Alloc(uint8_t, pitch.ValueOrDie());
     if (m_pColorSpace && m_bStdCS) {
-        m_pColorSpace->EnableStdConversion(TRUE);
+        m_pColorSpace->EnableStdConversion(true);
     }
     LoadPalette();
     if (m_bColorKey) {
@@ -335,9 +335,9 @@ int	CPDF_DIBSource::ContinueToLoadMask()
     m_Pitch = pitch.ValueOrDie();
     return 1;
 }
-int	CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* pStream, FX_BOOL bHasMask,
+int	CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* pStream, bool bHasMask,
                                        CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources,
-                                       FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
+                                       bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask)
 {
     if (pStream == NULL) {
         return 0;
@@ -366,7 +366,7 @@ int	CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* p
         return 0;
     }
     m_pStreamAcc = new CPDF_StreamAcc;
-    m_pStreamAcc->LoadAllData(pStream, FALSE, src_pitch.ValueOrDie(), TRUE);
+    m_pStreamAcc->LoadAllData(pStream, false, src_pitch.ValueOrDie(), true);
     if (m_pStreamAcc->GetSize() == 0 || m_pStreamAcc->GetData() == NULL) {
         return 0;
     }
@@ -393,7 +393,7 @@ int	CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* p
         return ret;
     }
     if (m_pColorSpace && m_bStdCS) {
-        m_pColorSpace->EnableStdConversion(FALSE);
+        m_pColorSpace->EnableStdConversion(false);
     }
     return ret;
 }
@@ -412,7 +412,7 @@ int	CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause)
                 CPDF_Stream* pGlobals = m_pStreamAcc->GetImageParam()->GetStream(FX_BSTRC("JBIG2Globals"));
                 if (pGlobals) {
                     m_pGlobalStream = new CPDF_StreamAcc;
-                    m_pGlobalStream->LoadAllData(pGlobals, FALSE);
+                    m_pGlobalStream->LoadAllData(pGlobals, false);
                 }
             }
             ret = pJbig2Module->StartDecode(m_pJbig2Context, m_Width, m_Height, m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(),
@@ -438,7 +438,7 @@ int	CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause)
                 return ret1;
             }
             if (m_pColorSpace && m_bStdCS) {
-                m_pColorSpace->EnableStdConversion(FALSE);
+                m_pColorSpace->EnableStdConversion(false);
             }
             return ret1;
         }
@@ -463,7 +463,7 @@ int	CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause)
             return ret1;
         }
         if (m_pColorSpace && m_bStdCS) {
-            m_pColorSpace->EnableStdConversion(FALSE);
+            m_pColorSpace->EnableStdConversion(false);
         }
         return ret1;
     }
@@ -472,11 +472,11 @@ int	CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause)
     }
     return 0;
 }
-FX_BOOL CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources)
+bool CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources)
 {
     m_bpc_orig = m_pDict->GetInteger(FX_BSTRC("BitsPerComponent"));
     if (m_pDict->GetInteger("ImageMask")) {
-        m_bImageMask = TRUE;
+        m_bImageMask = true;
     }
     if (m_bImageMask || !m_pDict->KeyExist(FX_BSTRC("ColorSpace"))) {
         if (!m_bImageMask) {
@@ -486,27 +486,27 @@ FX_BOOL CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dict
                 if (pFilter->GetType() == PDFOBJ_NAME) {
                     filter = pFilter->GetString();
                     if (filter == FX_BSTRC("JPXDecode")) {
-                        m_bDoBpcCheck = FALSE;
-                        return TRUE;
+                        m_bDoBpcCheck = false;
+                        return true;
                     }
                 } else if (pFilter->GetType() == PDFOBJ_ARRAY) {
                     CPDF_Array* pArray = (CPDF_Array*)pFilter;
                     if (pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("JPXDecode")) {
-                        m_bDoBpcCheck = FALSE;
-                        return TRUE;
+                        m_bDoBpcCheck = false;
+                        return true;
                     }
                 }
             }
         }
-        m_bImageMask = TRUE;
+        m_bImageMask = true;
         m_bpc = m_nComponents = 1;
         CPDF_Array* pDecode = m_pDict->GetArray(FX_BSTRC("Decode"));
         m_bDefaultDecode = pDecode == NULL || pDecode->GetInteger(0) == 0;
-        return TRUE;
+        return true;
     }
     CPDF_Object* pCSObj = m_pDict->GetElementValue(FX_BSTRC("ColorSpace"));
     if (pCSObj == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
     if (pFormResources) {
@@ -516,7 +516,7 @@ FX_BOOL CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dict
         m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pPageResources);
     }
     if (m_pColorSpace == NULL) {
-        return FALSE;
+        return false;
     }
     m_Family = m_pColorSpace->GetFamily();
     m_nComponents = m_pColorSpace->CountComponents();
@@ -533,11 +533,11 @@ FX_BOOL CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dict
     ValidateDictParam();
     m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
     if (m_pCompData == NULL) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, FX_BOOL& bColorKey)
+DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(bool& bDefaultDecode, bool& bColorKey)
 {
     if (m_pColorSpace == NULL) {
         return NULL;
@@ -556,7 +556,7 @@ DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, FX
                 def_max = (FX_FLOAT)max_data;
             }
             if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
-                bDefaultDecode = FALSE;
+                bDefaultDecode = false;
             }
         }
     } else {
@@ -584,7 +584,7 @@ DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, FX
                     pCompData[i].m_ColorKeyMax = FX_MIN(max_num, max_data);
                 }
             }
-            bColorKey = TRUE;
+            bColorKey = true;
         }
     }
     return pCompData;
@@ -612,7 +612,7 @@ int CPDF_DIBSource::CreateDecoder()
             src_data, src_size, m_Width, m_Height, m_nComponents,
             pParams ? pParams->GetInteger("ColorTransform", 1) : 1);
         if (!m_pDecoder) {
-            FX_BOOL bTransform = FALSE;
+            bool bTransform = false;
             int comps, bpc;
             ICodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
             if (pJpegModule->LoadInfo(src_data, src_size, m_Width, m_Height, comps, bpc, bTransform)) {
@@ -693,29 +693,29 @@ void CPDF_DIBSource::LoadJpxBitmap()
         return;
 
     int output_nComps;
-    FX_BOOL bTranslateColor;
-    FX_BOOL bSwapRGB = FALSE;
+    bool bTranslateColor;
+    bool bSwapRGB = false;
     if (m_pColorSpace) {
         if (codestream_nComps != (FX_DWORD)m_pColorSpace->CountComponents())
             return;
         output_nComps = codestream_nComps;
-        bTranslateColor = FALSE;
+        bTranslateColor = false;
         if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB)) {
-            bSwapRGB = TRUE;
+            bSwapRGB = true;
             m_pColorSpace = nullptr;
         }
     } else {
-        bTranslateColor = TRUE;
+        bTranslateColor = true;
         if (image_nComps) {
             output_nComps = image_nComps;
         } else {
             output_nComps = codestream_nComps;
         }
         if (output_nComps == 3) {
-            bSwapRGB = TRUE;
+            bSwapRGB = true;
         } else if (output_nComps == 4) {
             m_pColorSpace = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
-            bTranslateColor = FALSE;
+            bTranslateColor = false;
         }
         m_nComponents = output_nComps;
     }
@@ -829,7 +829,7 @@ int	CPDF_DIBSource::ContinueLoadMaskDIB(IFX_Pause* pPause)
         return ret;
     }
     if (m_pColorSpace && m_bStdCS) {
-        m_pColorSpace->EnableStdConversion(FALSE);
+        m_pColorSpace->EnableStdConversion(false);
     }
     if (!ret) {
         delete m_pMask;
@@ -847,7 +847,7 @@ CPDF_DIBSource*	CPDF_DIBSource::DetachMask()
 CPDF_DIBSource* CPDF_DIBSource::LoadMaskDIB(CPDF_Stream* pMask)
 {
     CPDF_DIBSource* pMaskSource = new CPDF_DIBSource;
-    if (!pMaskSource->Load(m_pDocument, pMask, NULL, NULL, NULL, NULL, TRUE)) {
+    if (!pMaskSource->Load(m_pDocument, pMask, NULL, NULL, NULL, NULL, true)) {
         delete pMaskSource;
         return NULL;
     }
@@ -856,7 +856,7 @@ CPDF_DIBSource* CPDF_DIBSource::LoadMaskDIB(CPDF_Stream* pMask)
 int CPDF_DIBSource::StartLoadMaskDIB()
 {
     m_pMask = new CPDF_DIBSource;
-    int ret = m_pMask->StartLoadDIBSource(m_pDocument, (CPDF_Stream*)m_pMaskStream, FALSE, NULL, NULL, TRUE);
+    int ret = m_pMask->StartLoadDIBSource(m_pDocument, (CPDF_Stream*)m_pMaskStream, false, NULL, NULL, true);
     if (ret == 2) {
         if (m_Status == 0) {
             m_Status = 2;
@@ -1209,15 +1209,15 @@ const uint8_t* CPDF_DIBSource::GetScanline(int line) const
     }
     return pSrcLine;
 }
-FX_BOOL CPDF_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const
+bool CPDF_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const
 {
     if (m_pDecoder) {
         return m_pDecoder->SkipToScanline(line, pPause);
     }
-    return FALSE;
+    return false;
 }
 void CPDF_DIBSource::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-                                        int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
+                                        int dest_width, bool bFlipX, int clip_left, int clip_width) const
 {
     if (line < 0 || dest_scan == NULL || dest_bpp <= 0 ||
         dest_width <= 0 || clip_left < 0 || clip_width <= 0) {
@@ -1480,26 +1480,26 @@ CPDF_ProgressiveImageLoaderHandle::CPDF_ProgressiveImageLoaderHandle()
 CPDF_ProgressiveImageLoaderHandle::~CPDF_ProgressiveImageLoaderHandle()
 {
 }
-FX_BOOL CPDF_ProgressiveImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader, const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t nDownsampleWidth, int32_t nDownsampleHeight)
+bool CPDF_ProgressiveImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader, const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t nDownsampleWidth, int32_t nDownsampleHeight)
 {
     m_pImageLoader = pImageLoader;
     m_pCache = pCache;
     m_pImage = (CPDF_ImageObject*)pImage;
     m_nDownsampleWidth = nDownsampleWidth;
     m_nDownsampleHeight = nDownsampleHeight;
-    FX_BOOL ret;
+    bool ret;
     if (pCache) {
         ret = pCache->StartGetCachedBitmap(pImage->m_pImage->GetStream(), bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
-        if (ret == FALSE) {
-            m_pImageLoader->m_bCached = TRUE;
+        if (ret == false) {
+            m_pImageLoader->m_bCached = true;
             m_pImageLoader->m_pBitmap = pCache->m_pCurImageCache->DetachBitmap();
             m_pImageLoader->m_pMask = pCache->m_pCurImageCache->DetachMask();
             m_pImageLoader->m_MatteColor = pCache->m_pCurImageCache->m_MatteColor;
         }
     } else {
         ret = pImage->m_pImage->StartLoadDIBSource(pRenderStatus->m_pFormResource, pRenderStatus->m_pPageResource, bStdCS, GroupFamily, bLoadMask);
-        if (ret == FALSE) {
-            m_pImageLoader->m_bCached = FALSE;
+        if (ret == false) {
+            m_pImageLoader->m_bCached = false;
             m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
             m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
             m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
@@ -1507,21 +1507,21 @@ FX_BOOL CPDF_ProgressiveImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader,
     }
     return ret;
 }
-FX_BOOL CPDF_ProgressiveImageLoaderHandle::Continue(IFX_Pause* pPause)
+bool CPDF_ProgressiveImageLoaderHandle::Continue(IFX_Pause* pPause)
 {
-    FX_BOOL ret;
+    bool ret;
     if (m_pCache) {
         ret = m_pCache->Continue(pPause);
-        if (ret == FALSE) {
-            m_pImageLoader->m_bCached = TRUE;
+        if (ret == false) {
+            m_pImageLoader->m_bCached = true;
             m_pImageLoader->m_pBitmap = m_pCache->m_pCurImageCache->DetachBitmap();
             m_pImageLoader->m_pMask = m_pCache->m_pCurImageCache->DetachMask();
             m_pImageLoader->m_MatteColor = m_pCache->m_pCurImageCache->m_MatteColor;
         }
     } else {
         ret = m_pImage->m_pImage->Continue(pPause);
-        if (ret == FALSE) {
-            m_pImageLoader->m_bCached = FALSE;
+        if (ret == false) {
+            m_pImageLoader->m_bCached = false;
             m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
             m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
             m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
@@ -1529,30 +1529,30 @@ FX_BOOL CPDF_ProgressiveImageLoaderHandle::Continue(IFX_Pause* pPause)
     }
     return ret;
 }
-FX_BOOL CPDF_ImageLoader::Load(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus)
+bool CPDF_ImageLoader::Load(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus)
 {
     if (pImage == NULL) {
-        return FALSE;
+        return false;
     }
     if (pCache) {
         pCache->GetCachedBitmap(pImage->m_pImage->GetStream(), m_pBitmap, m_pMask, m_MatteColor, bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
-        m_bCached = TRUE;
+        m_bCached = true;
     } else {
         m_pBitmap = pImage->m_pImage->LoadDIBSource(&m_pMask, &m_MatteColor, bStdCS, GroupFamily, bLoadMask);
-        m_bCached = FALSE;
+        m_bCached = false;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_ImageLoader::StartLoadImage(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, void*& LoadHandle, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t nDownsampleWidth, int32_t nDownsampleHeight)
+bool CPDF_ImageLoader::StartLoadImage(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, void*& LoadHandle, bool bStdCS, FX_DWORD GroupFamily, bool bLoadMask, CPDF_RenderStatus* pRenderStatus, int32_t nDownsampleWidth, int32_t nDownsampleHeight)
 {
     m_nDownsampleWidth = nDownsampleWidth;
     m_nDownsampleHeight = nDownsampleHeight;
     CPDF_ProgressiveImageLoaderHandle* pLoaderHandle = new CPDF_ProgressiveImageLoaderHandle;
-    FX_BOOL ret = pLoaderHandle->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
+    bool ret = pLoaderHandle->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
     LoadHandle = pLoaderHandle;
     return ret;
 }
-FX_BOOL	CPDF_ImageLoader::Continue(void* LoadHandle, IFX_Pause* pPause)
+bool	CPDF_ImageLoader::Continue(void* LoadHandle, IFX_Pause* pPause)
 {
     return ((CPDF_ProgressiveImageLoaderHandle*)LoadHandle)->Continue(pPause);
 }
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
index 3ee2222d8b..e08649062c 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_pattern.cpp
@@ -29,7 +29,7 @@ static void _DrawAxialShading(CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2B
         t_min = pArray->GetNumber(0);
         t_max = pArray->GetNumber(1);
     }
-    FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
+    bool bStartExtend = false, bEndExtend = false;
     pArray = pDict->GetArray(FX_BSTRC("Extend"));
     if (pArray) {
         bStartExtend = pArray->GetInteger(0);
@@ -116,7 +116,7 @@ static void _DrawRadialShading(CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2
         t_min = pArray->GetNumber(0);
         t_max = pArray->GetNumber(1);
     }
-    FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
+    bool bStartExtend = false, bEndExtend = false;
     pArray = pDict->GetArray(FX_BSTRC("Extend"));
     if (pArray) {
         bStartExtend = pArray->GetInteger(0);
@@ -155,11 +155,11 @@ static void _DrawRadialShading(CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2
     int width = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     int pitch = pBitmap->GetPitch();
-    FX_BOOL bDecreasing = FALSE;
+    bool bDecreasing = false;
     if (start_r > end_r) {
         int length = (int)FXSYS_sqrt((FXSYS_Mul(start_x - end_x, start_x - end_x) + FXSYS_Mul(start_y - end_y, start_y - end_y)));
         if (length < start_r - end_r) {
-            bDecreasing = TRUE;
+            bDecreasing = true;
         }
     }
     for (int row = 0; row < height; row ++) {
@@ -281,22 +281,22 @@ static void _DrawFuncShading(CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2Bi
         }
     }
 }
-FX_BOOL _GetScanlineIntersect(int y, FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_FLOAT& x)
+bool _GetScanlineIntersect(int y, FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_FLOAT& x)
 {
     if (y1 == y2) {
-        return FALSE;
+        return false;
     }
     if (y1 < y2) {
         if (y < y1 || y > y2) {
-            return FALSE;
+            return false;
         }
     } else {
         if (y < y2 || y > y1) {
-            return FALSE;
+            return false;
         }
     }
     x = x1 + FXSYS_MulDiv(x2 - x1, y - y1, y2 - y1);
-    return TRUE;
+    return true;
 }
 static void _DrawGouraud(CFX_DIBitmap* pBitmap, int alpha, CPDF_MeshVertex triangle[3])
 {
@@ -325,7 +325,7 @@ static void _DrawGouraud(CFX_DIBitmap* pBitmap, int alpha, CPDF_MeshVertex trian
         for (int i = 0; i < 3; i ++) {
             CPDF_MeshVertex& vertex1 = triangle[i];
             CPDF_MeshVertex& vertex2 = triangle[(i + 1) % 3];
-            FX_BOOL bIntersect = _GetScanlineIntersect(y, vertex1.x, vertex1.y,
+            bool bIntersect = _GetScanlineIntersect(y, vertex1.x, vertex1.y,
                                  vertex2.x, vertex2.y, inter_x[nIntersects]);
             if (!bIntersect) {
                 continue;
@@ -601,7 +601,7 @@ struct CPDF_PatchDrawer {
     int					alpha;
     void Draw(int x_scale, int y_scale, int left, int bottom, Coon_Bezier C1, Coon_Bezier C2, Coon_Bezier D1, Coon_Bezier D2)
     {
-        FX_BOOL bSmall = C1.Distance() < 2 && C2.Distance() < 2 && D1.Distance() < 2 && D2.Distance() < 2;
+        bool bSmall = C1.Distance() < 2 && C2.Distance() < 2 && D1.Distance() < 2 && D2.Distance() < 2;
         Coon_Color div_colors[4];
         int d_bottom, d_left, d_top, d_right;
         div_colors[0].BiInterpol(patch_colors, left, bottom, x_scale, y_scale);
@@ -663,9 +663,9 @@ struct CPDF_PatchDrawer {
     }
 };
 
-FX_BOOL _CheckCoonTensorPara(const CPDF_MeshStream &stream)
+bool _CheckCoonTensorPara(const CPDF_MeshStream &stream)
 {
-    FX_BOOL bCoorBits = ( stream.m_nCoordBits== 1   ||
+    bool bCoorBits = ( stream.m_nCoordBits== 1   ||
                           stream.m_nCoordBits == 2  ||
                           stream.m_nCoordBits == 4  ||
                           stream.m_nCoordBits == 8  ||
@@ -674,21 +674,21 @@ FX_BOOL _CheckCoonTensorPara(const CPDF_MeshStream &stream)
                           stream.m_nCoordBits == 24 ||
                           stream.m_nCoordBits == 32   );
 
-    FX_BOOL bCompBits = ( stream.m_nCompBits == 1  ||
+    bool bCompBits = ( stream.m_nCompBits == 1  ||
                           stream.m_nCompBits == 2  ||
                           stream.m_nCompBits == 4  ||
                           stream.m_nCompBits == 8  ||
                           stream.m_nCompBits == 12 ||
                           stream.m_nCompBits == 16   );
 
-    FX_BOOL bFlagBits = ( stream.m_nFlagBits == 2  ||
+    bool bFlagBits = ( stream.m_nFlagBits == 2  ||
                           stream.m_nFlagBits == 4  ||
                           stream.m_nFlagBits == 8    );
 
     return bCoorBits && bCompBits && bFlagBits;
 }
 
-static void _DrawCoonPatchMeshes(FX_BOOL bTensor, CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2Bitmap,
+static void _DrawCoonPatchMeshes(bool bTensor, CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2Bitmap,
                                  CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs,
                                  CPDF_ColorSpace* pCS, int fill_mode, int alpha)
 {
@@ -768,7 +768,7 @@ static void _DrawCoonPatchMeshes(FX_BOOL bTensor, CFX_DIBitmap* pBitmap, CFX_Aff
     }
 }
 void CPDF_RenderStatus::DrawShading(CPDF_ShadingPattern* pPattern, CFX_AffineMatrix* pMatrix,
-                                    FX_RECT& clip_rect, int alpha, FX_BOOL bAlphaMode)
+                                    FX_RECT& clip_rect, int alpha, bool bAlphaMode)
 {
     CPDF_Function** pFuncs = pPattern->m_pFunctions;
     int nFuncs = pPattern->m_nFuncs;
@@ -840,7 +840,7 @@ void CPDF_RenderStatus::DrawShading(CPDF_ShadingPattern* pPattern, CFX_AffineMat
     }
     buffer.OutputToDevice();
 }
-void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke)
 {
     if (!pattern->Load()) {
         return;
@@ -858,7 +858,7 @@ void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_Pa
         return;
     }
     FX_RECT rect;
-    if (GetObjectClippedRect(pPageObj, pObj2Device, FALSE, rect)) {
+    if (GetObjectClippedRect(pPageObj, pObj2Device, false, rect)) {
         m_pDevice->RestoreState();
         return;
     }
@@ -869,19 +869,19 @@ void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_Pa
     DrawShading(pattern, &matrix, rect, alpha, m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
     m_pDevice->RestoreState();
 }
-FX_BOOL CPDF_RenderStatus::ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device)
 {
     FX_RECT rect = pShadingObj->GetBBox(pObj2Device);
     FX_RECT clip_box = m_pDevice->GetClipBox();
     rect.Intersect(clip_box);
     if (rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     CFX_AffineMatrix matrix = pShadingObj->m_Matrix;
     matrix.Concat(*pObj2Device);
-    DrawShading(pShadingObj->m_pShading, &matrix, rect, pShadingObj->m_GeneralState.GetAlpha(FALSE),
+    DrawShading(pShadingObj->m_pShading, &matrix, rect, pShadingObj->m_GeneralState.GetAlpha(false),
                 m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
-    return TRUE;
+    return true;
 }
 static CFX_DIBitmap* DrawPatternBitmap(CPDF_Document* pDoc, CPDF_PageRenderCache* pCache,
                                        CPDF_TilingPattern* pPattern, const CFX_AffineMatrix* pObject2Device,
@@ -914,7 +914,7 @@ static CFX_DIBitmap* DrawPatternBitmap(CPDF_Document* pDoc, CPDF_PageRenderCache
     context.DrawObjectList(&bitmap_device, pPattern->m_pForm, &mtPattern2Bitmap, &options);
     return pBitmap;
 }
-void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke)
 {
     if (!pPattern->Load()) {
         return;
@@ -944,11 +944,11 @@ void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_Pag
     CFX_AffineMatrix mtPattern2Device = pPattern->m_Pattern2Form;
     mtPattern2Device.Concat(*pObj2Device);
     GetScaledMatrix(mtPattern2Device);
-    FX_BOOL bAligned = FALSE;
+    bool bAligned = false;
     if (pPattern->m_BBox.left == 0 && pPattern->m_BBox.bottom == 0 &&
             pPattern->m_BBox.right == pPattern->m_XStep && pPattern->m_BBox.top == pPattern->m_YStep &&
             (mtPattern2Device.IsScaled() || mtPattern2Device.Is90Rotated())) {
-        bAligned = TRUE;
+        bAligned = true;
     }
     CFX_FloatRect cell_bbox = pPattern->m_BBox;
     mtPattern2Device.TransformRect(cell_bbox);
@@ -1075,11 +1075,11 @@ void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_Pag
             }
         }
     }
-    CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255, FXDIB_BLEND_NORMAL, FALSE);
+    CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255, FXDIB_BLEND_NORMAL, false);
     m_pDevice->RestoreState();
     delete pPatternBitmap;
 }
-void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, bool bStroke)
 {
     CPDF_Pattern* pattern = pColor->GetPattern();
     if (pattern == NULL) {
@@ -1091,20 +1091,20 @@ void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX
         DrawShadingPattern((CPDF_ShadingPattern*)pattern, pPathObj, pObj2Device, bStroke);
     }
 }
-void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, FX_BOOL& bStroke)
+void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, bool& bStroke)
 {
     if(filltype) {
         CPDF_Color& FillColor = *pPathObj->m_ColorState.GetFillColor();
         if(FillColor.m_pCS && FillColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
-            DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, FALSE);
+            DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, false);
             filltype = 0;
         }
     }
     if(bStroke) {
         CPDF_Color& StrokeColor = *pPathObj->m_ColorState.GetStrokeColor();
         if(StrokeColor.m_pCS && StrokeColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
-            DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, TRUE);
-            bStroke = FALSE;
+            DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, true);
+            bStroke = false;
         }
     }
 }
diff --git a/core/src/fpdfapi/fpdf_render/fpdf_render_text.cpp b/core/src/fpdfapi/fpdf_render/fpdf_render_text.cpp
index ad5dc58a1c..26138a9fbf 100644
--- a/core/src/fpdfapi/fpdf_render/fpdf_render_text.cpp
+++ b/core/src/fpdfapi/fpdf_render/fpdf_render_text.cpp
@@ -9,7 +9,7 @@
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../fpdf_page/pageint.h"
 #include "render_int.h"
-extern FX_BOOL IsAvailableMatrix(const CFX_AffineMatrix& matrix);
+extern bool IsAvailableMatrix(const CFX_AffineMatrix& matrix);
 CPDF_Type3Cache::~CPDF_Type3Cache()
 {
     FX_POSITION pos = m_SizeMap.GetStartPosition();
@@ -76,28 +76,28 @@ void CPDF_Type3Glyphs::AdjustBlue(FX_FLOAT top, FX_FLOAT bottom, int& top_line,
     top_line = _AdjustBlue(top, m_TopBlueCount, m_TopBlue);
     bottom_line = _AdjustBlue(bottom, m_BottomBlueCount, m_BottomBlue);
 }
-static FX_BOOL _IsScanLine1bpp(uint8_t* pBuf, int width)
+static bool _IsScanLine1bpp(uint8_t* pBuf, int width)
 {
     int size = width / 8;
     for (int i = 0; i < size; i ++)
         if (pBuf[i]) {
-            return TRUE;
+            return true;
         }
     if (width % 8)
         if (pBuf[width / 8] & (0xff << (8 - width % 8))) {
-            return TRUE;
+            return true;
         }
-    return FALSE;
+    return false;
 }
-static FX_BOOL _IsScanLine8bpp(uint8_t* pBuf, int width)
+static bool _IsScanLine8bpp(uint8_t* pBuf, int width)
 {
     for (int i = 0; i < width; i ++)
         if (pBuf[i] > 0x40) {
-            return TRUE;
+            return true;
         }
-    return FALSE;
+    return false;
 }
-static int _DetectFirstLastScan(const CFX_DIBitmap* pBitmap, FX_BOOL bFirst)
+static int _DetectFirstLastScan(const CFX_DIBitmap* pBitmap, bool bFirst)
 {
     int height = pBitmap->GetHeight(), pitch = pBitmap->GetPitch(), width = pBitmap->GetWidth();
     int bpp = pBitmap->GetBPP();
@@ -137,12 +137,12 @@ CFX_GlyphBitmap* CPDF_Type3Cache::RenderGlyph(CPDF_Type3Glyphs* pSize, FX_DWORD
     int left, top;
     if (FXSYS_fabs(image_matrix.b) < FXSYS_fabs(image_matrix.a) / 100 && FXSYS_fabs(image_matrix.c) < FXSYS_fabs(image_matrix.d) / 100) {
         int top_line, bottom_line;
-        top_line = _DetectFirstLastScan(pBitmap, TRUE);
-        bottom_line = _DetectFirstLastScan(pBitmap, FALSE);
+        top_line = _DetectFirstLastScan(pBitmap, true);
+        bottom_line = _DetectFirstLastScan(pBitmap, false);
         if (top_line == 0 && bottom_line == pBitmap->GetHeight() - 1) {
             FX_FLOAT top_y = image_matrix.d + image_matrix.f;
             FX_FLOAT bottom_y = image_matrix.f;
-            FX_BOOL bFlipped = top_y > bottom_y;
+            bool bFlipped = top_y > bottom_y;
             if (bFlipped) {
                 FX_FLOAT temp = top_y;
                 top_y = bottom_y;
@@ -185,76 +185,76 @@ void _CPDF_UniqueKeyGen::Generate(int count, ...)
     va_end(argList);
     m_KeyLen = count * sizeof(FX_DWORD);
 }
-FX_BOOL CPDF_RenderStatus::ProcessText(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device, CFX_PathData* pClippingPath)
+bool CPDF_RenderStatus::ProcessText(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device, CFX_PathData* pClippingPath)
 {
     if(textobj->m_nChars == 0) {
-        return TRUE;
+        return true;
     }
     int text_render_mode = textobj->m_TextState.GetObject()->m_TextMode;
     if (text_render_mode == 3) {
-        return TRUE;
+        return true;
     }
     CPDF_Font* pFont = textobj->m_TextState.GetFont();
     if (pFont->GetFontType() == PDFFONT_TYPE3) {
         return ProcessType3Text(textobj, pObj2Device);
     }
-    FX_BOOL bFill = FALSE, bStroke = FALSE, bClip = FALSE;
+    bool bFill = false, bStroke = false, bClip = false;
     if (pClippingPath) {
-        bClip = TRUE;
+        bClip = true;
     } else {
         switch (text_render_mode) {
             case 0:
             case 4:
-                bFill = TRUE;
+                bFill = true;
                 break;
             case 1:
             case 5:
                 if (pFont->GetFace() == NULL && !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
-                    bFill = TRUE;
+                    bFill = true;
                 } else {
-                    bStroke = TRUE;
+                    bStroke = true;
                 }
                 break;
             case 2:
             case 6:
                 if (pFont->GetFace() == NULL && !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
-                    bFill = TRUE;
+                    bFill = true;
                 } else {
-                    bFill = bStroke = TRUE;
+                    bFill = bStroke = true;
                 }
                 break;
             case 3:
             case 7:
-                return TRUE;
+                return true;
             default:
-                bFill = TRUE;
+                bFill = true;
         }
     }
     FX_ARGB stroke_argb = 0, fill_argb = 0;
-    FX_BOOL bPattern = FALSE;
+    bool bPattern = false;
     if (bStroke) {
         if (textobj->m_ColorState.GetStrokeColor()->IsPattern()) {
-            bPattern = TRUE;
+            bPattern = true;
         } else {
             stroke_argb = GetStrokeArgb(textobj);
         }
     }
     if (bFill) {
         if (textobj->m_ColorState.GetFillColor()->IsPattern()) {
-            bPattern = TRUE;
+            bPattern = true;
         } else {
             fill_argb = GetFillArgb(textobj);
         }
     }
     CFX_AffineMatrix text_matrix;
     textobj->GetTextMatrix(&text_matrix);
-    if(IsAvailableMatrix(text_matrix) == FALSE) {
-        return TRUE;
+    if(IsAvailableMatrix(text_matrix) == false) {
+        return true;
     }
     FX_FLOAT font_size = textobj->m_TextState.GetFontSize();
     if (bPattern) {
         DrawTextPathWithPattern(textobj, pObj2Device, pFont, font_size, &text_matrix, bFill, bStroke);
-        return TRUE;
+        return true;
     }
     if (bClip || bStroke) {
         const CFX_AffineMatrix* pDeviceMatrix = pObj2Device;
@@ -293,7 +293,7 @@ CPDF_Type3Cache* CPDF_RenderStatus::GetCachedType3(CPDF_Type3Font* pFont)
     if (pFont->m_pDocument == NULL) {
         return NULL;
     }
-    pFont->m_pDocument->GetPageData()->GetFont(pFont->GetFontDict(), FALSE);
+    pFont->m_pDocument->GetPageData()->GetFont(pFont->GetFontDict(), false);
     return pFont->m_pDocument->GetRenderData()->GetCachedType3(pFont);
 }
 static void ReleaseCachedType3(CPDF_Type3Font* pFont)
@@ -304,10 +304,10 @@ static void ReleaseCachedType3(CPDF_Type3Font* pFont)
     pFont->m_pDocument->GetRenderData()->ReleaseCachedType3(pFont);
     pFont->m_pDocument->GetPageData()->ReleaseFont(pFont->GetFontDict());
 }
-FX_BOOL CPDF_Type3Char::LoadBitmap(CPDF_RenderContext* pContext)
+bool CPDF_Type3Char::LoadBitmap(CPDF_RenderContext* pContext)
 {
     if (m_pBitmap != NULL || m_pForm == NULL) {
-        return TRUE;
+        return true;
     }
     if (m_pForm->CountObjects() == 1 && !m_bColored) {
         CPDF_PageObject *pPageObj = m_pForm->GetObjectAt(m_pForm->GetFirstObjectPosition());
@@ -321,10 +321,10 @@ FX_BOOL CPDF_Type3Char::LoadBitmap(CPDF_RenderContext* pContext)
             }
             delete m_pForm;
             m_pForm = NULL;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 class CPDF_RefType3Cache
 {
@@ -343,12 +343,12 @@ public:
     FX_DWORD m_dwCount;
     CPDF_Type3Font* m_pType3Font;
 };
-FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device)
 {
     CPDF_Type3Font* pType3Font = textobj->m_TextState.GetFont()->GetType3Font();
     for (int j = 0; j < m_Type3FontCache.GetSize(); j++)
         if ((CPDF_Type3Font*)m_Type3FontCache.GetAt(j) == pType3Font) {
-            return TRUE;
+            return true;
         }
     CFX_Matrix dCTM = m_pDevice->GetCTM();
     FX_FLOAT sa = FXSYS_fabs(dCTM.a);
@@ -358,14 +358,14 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
     CFX_AffineMatrix char_matrix = pType3Font->GetFontMatrix();
     FX_FLOAT font_size = textobj->m_TextState.GetFontSize();
     char_matrix.Scale(font_size, font_size);
-    FX_ARGB fill_argb = GetFillArgb(textobj, TRUE);
+    FX_ARGB fill_argb = GetFillArgb(textobj, true);
     int fill_alpha = FXARGB_A(fill_argb);
     int device_class = m_pDevice->GetDeviceClass();
     FXTEXT_GLYPHPOS* pGlyphAndPos = NULL;
     if (device_class == FXDC_DISPLAY) {
         pGlyphAndPos = FX_Alloc(FXTEXT_GLYPHPOS, textobj->m_nChars);
     } else if (fill_alpha < 255) {
-        return FALSE;
+        return false;
     }
     CPDF_RefType3Cache refTypeCache(pType3Font);
     FX_DWORD *pChars = textobj->m_pCharCodes;
@@ -399,7 +399,7 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
                 FX_Free(pGlyphAndPos);
                 pGlyphAndPos = NULL;
             }
-            CPDF_GraphicStates* pStates = CloneObjStates(textobj, FALSE);
+            CPDF_GraphicStates* pStates = CloneObjStates(textobj, false);
             CPDF_RenderOptions Options = m_Options;
             Options.m_Flags |= RENDER_FORCE_HALFTONE | RENDER_RECT_AA;
             Options.m_Flags &= ~RENDER_FORCE_DOWNSAMPLE;
@@ -410,7 +410,7 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
             if (fill_alpha == 255) {
                 CPDF_RenderStatus status;
                 status.Initialize(m_pContext, m_pDevice, NULL, NULL, this, pStates, &Options,
-                                  pType3Char->m_pForm->m_Transparency, m_bDropObjects, pFormResource, FALSE, pType3Char, fill_argb);
+                                  pType3Char->m_pForm->m_Transparency, m_bDropObjects, pFormResource, false, pType3Char, fill_argb);
                 status.m_Type3FontCache.Append(m_Type3FontCache);
                 status.m_Type3FontCache.Add(pType3Font);
                 m_pDevice->SaveState();
@@ -422,12 +422,12 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
                 FX_RECT rect = rect_f.GetOutterRect();
                 CFX_FxgeDevice bitmap_device;
                 if (!bitmap_device.Create((int)(rect.Width() * sa), (int)(rect.Height() * sd), FXDIB_Argb)) {
-                    return TRUE;
+                    return true;
                 }
                 bitmap_device.GetBitmap()->Clear(0);
                 CPDF_RenderStatus status;
                 status.Initialize(m_pContext, &bitmap_device, NULL, NULL, this, pStates, &Options,
-                                  pType3Char->m_pForm->m_Transparency, m_bDropObjects, pFormResource, FALSE, pType3Char, fill_argb);
+                                  pType3Char->m_pForm->m_Transparency, m_bDropObjects, pFormResource, false, pType3Char, fill_argb);
                 status.m_Type3FontCache.Append(m_Type3FontCache);
                 status.m_Type3FontCache.Add(pType3Font);
                 matrix.TranslateI(-rect.left, -rect.top);
@@ -457,11 +457,11 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
                 CFX_AffineMatrix image_matrix = pType3Char->m_ImageMatrix;
                 image_matrix.Concat(matrix);
                 CPDF_ImageRenderer renderer;
-                if (renderer.Start(this, pType3Char->m_pBitmap, fill_argb, 255, &image_matrix, 0, FALSE)) {
+                if (renderer.Start(this, pType3Char->m_pBitmap, fill_argb, 255, &image_matrix, 0, false)) {
                     renderer.Continue(NULL);
                 }
                 if (!renderer.m_Result) {
-                    return FALSE;
+                    return false;
                 }
             }
         }
@@ -471,7 +471,7 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
         CFX_DIBitmap bitmap;
         if (!bitmap.Create((int)(rect.Width() * sa), (int)(rect.Height() * sd), FXDIB_8bppMask)) {
             FX_Free(pGlyphAndPos);
-            return TRUE;
+            return true;
         }
         bitmap.Clear(0);
         for (int iChar = 0; iChar < textobj->m_nChars; iChar ++) {
@@ -487,7 +487,7 @@ FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj, cons
         m_pDevice->SetBitMask(&bitmap, rect.left, rect.top, fill_argb);
         FX_Free(pGlyphAndPos);
     }
-    return TRUE;
+    return true;
 }
 class CPDF_CharPosList
 {
@@ -515,13 +515,13 @@ void CPDF_CharPosList::Load(int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos
     m_pCharPos = FX_Alloc(FXTEXT_CHARPOS, nChars);
     m_nChars = 0;
     CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
-    FX_BOOL bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
+    bool bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
     for (int iChar = 0; iChar < nChars; iChar ++) {
         FX_DWORD CharCode = nChars == 1 ? (FX_DWORD)(uintptr_t)pCharCodes : pCharCodes[iChar];
         if (CharCode == (FX_DWORD) - 1) {
             continue;
         }
-        FX_BOOL bVert = FALSE;
+        bool bVert = false;
         FXTEXT_CHARPOS& charpos = m_pCharPos[m_nChars++];
         if (pCIDFont) {
             charpos.m_bFontStyle = pCIDFont->IsFontStyleFromCharCode(CharCode);
@@ -537,7 +537,7 @@ void CPDF_CharPosList::Load(int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos
         }
         charpos.m_OriginX = iChar ? pCharPos[iChar - 1] : 0;
         charpos.m_OriginY = 0;
-        charpos.m_bGlyphAdjust = FALSE;
+        charpos.m_bGlyphAdjust = false;
         if (pCIDFont == NULL) {
             continue;
         }
@@ -558,11 +558,11 @@ void CPDF_CharPosList::Load(int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos
             charpos.m_AdjustMatrix[3] = _CIDTransformToFloat(pTransform[3]);
             charpos.m_OriginX += _CIDTransformToFloat(pTransform[4]) * FontSize;
             charpos.m_OriginY += _CIDTransformToFloat(pTransform[5]) * FontSize;
-            charpos.m_bGlyphAdjust = TRUE;
+            charpos.m_bGlyphAdjust = true;
         }
     }
 }
-FX_BOOL CPDF_TextRenderer::DrawTextPath(CFX_RenderDevice* pDevice, int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos,
+bool CPDF_TextRenderer::DrawTextPath(CFX_RenderDevice* pDevice, int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos,
                                         CPDF_Font* pFont, FX_FLOAT font_size,
                                         const CFX_AffineMatrix* pText2User, const CFX_AffineMatrix* pUser2Device,
                                         const CFX_GraphStateData* pGraphState,
@@ -632,7 +632,7 @@ void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice, FX_FLOAT origi
         FX_Free(pCharPos);
     }
 }
-FX_BOOL CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice, int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos,
+bool CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice, int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos,
         CPDF_Font* pFont, FX_FLOAT font_size,
         const CFX_AffineMatrix* pText2Device,
         FX_ARGB fill_argb, const CPDF_RenderOptions* pOptions)
@@ -671,13 +671,13 @@ FX_BOOL CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice, int nChars,
 }
 void CPDF_RenderStatus::DrawTextPathWithPattern(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device,
         CPDF_Font* pFont, FX_FLOAT font_size,
-        const CFX_AffineMatrix* pTextMatrix, FX_BOOL bFill, FX_BOOL bStroke)
+        const CFX_AffineMatrix* pTextMatrix, bool bFill, bool bStroke)
 {
     if (!bStroke) {
         CPDF_PathObject path;
         CPDF_TextObject* pCopy = new CPDF_TextObject;
         pCopy->Copy(textobj);
-        path.m_bStroke = FALSE;
+        path.m_bStroke = false;
         path.m_FillType = FXFILL_WINDING;
         path.m_ClipPath.AppendTexts(&pCopy, 1);
         path.m_ColorState = textobj->m_ColorState;
diff --git a/core/src/fpdfapi/fpdf_render/render_int.h b/core/src/fpdfapi/fpdf_render/render_int.h
index e5fb831a63..c9c8944a0b 100644
--- a/core/src/fpdfapi/fpdf_render/render_int.h
+++ b/core/src/fpdfapi/fpdf_render/render_int.h
@@ -49,9 +49,9 @@ class CPDF_TransferFunc
 public:
     CPDF_Document*	m_pPDFDoc;
     uint8_t			m_Samples[256 * 3];
-    FX_BOOL			m_bIdentity;
+    bool			m_bIdentity;
 
-    CFX_DIBSource*	TranslateImage(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc);
+    CFX_DIBSource*	TranslateImage(const CFX_DIBSource* pSrc, bool bAutoDropSrc);
     FX_COLORREF		TranslateColor(FX_COLORREF src);
 };
 
@@ -66,7 +66,7 @@ public:
     {
         return m_pFontCache;
     }
-    void				Clear(FX_BOOL bRelease = FALSE);
+    void				Clear(bool bRelease = false);
     void				ReleaseCachedType3(CPDF_Type3Font* pFont);
     void				ReleaseTransferFunc(CPDF_Object* pObj);
 private:
@@ -91,24 +91,24 @@ class IPDF_ObjectRenderer
 public:
     static IPDF_ObjectRenderer* Create(int type);
     virtual ~IPDF_ObjectRenderer() {}
-    virtual FX_BOOL Start(CPDF_RenderStatus* pRenderStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStdCS, int blendType = FXDIB_BLEND_NORMAL) = 0;
-    virtual FX_BOOL Continue(IFX_Pause* pPause) = 0;
-    FX_BOOL		m_Result;
+    virtual bool Start(CPDF_RenderStatus* pRenderStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, bool bStdCS, int blendType = FXDIB_BLEND_NORMAL) = 0;
+    virtual bool Continue(IFX_Pause* pPause) = 0;
+    bool		m_Result;
 };
 class CPDF_RenderStatus
 {
 public:
     CPDF_RenderStatus();
     ~CPDF_RenderStatus();
-    FX_BOOL			Initialize(class CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pDeviceMatrix,
+    bool			Initialize(class CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pDeviceMatrix,
                                const CPDF_PageObject* pStopObj, const CPDF_RenderStatus* pParentStatus,
                                const CPDF_GraphicStates* pInitialStates, const CPDF_RenderOptions* pOptions,
-                               int transparency, FX_BOOL bDropObjects, CPDF_Dictionary* pFormResource = NULL,
-                               FX_BOOL bStdCS = FALSE,	CPDF_Type3Char* pType3Char = NULL, FX_ARGB fill_color = 0,
-                               FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE);
+                               int transparency, bool bDropObjects, CPDF_Dictionary* pFormResource = NULL,
+                               bool bStdCS = false,	CPDF_Type3Char* pType3Char = NULL, FX_ARGB fill_color = 0,
+                               FX_DWORD GroupFamily = 0, bool bLoadMask = false);
     void			RenderObjectList(const CPDF_PageObjects* pObjs, const CFX_AffineMatrix* pObj2Device);
     void			RenderSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause);
+    bool			ContinueSingleObject(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, IFX_Pause* pPause);
     CPDF_RenderOptions	m_Options;
     CPDF_Dictionary*    m_pFormResource;
     CPDF_Dictionary*    m_pPageResource;
@@ -122,45 +122,45 @@ protected:
     friend class	CPDF_RenderContext;
     void			ProcessClipPath(CPDF_ClipPath ClipPath, const CFX_AffineMatrix* pObj2Device);
     void			DrawClipPath(CPDF_ClipPath ClipPath, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			ProcessTransparency(const CPDF_PageObject* PageObj, const CFX_AffineMatrix* pObj2Device);
+    bool			ProcessTransparency(const CPDF_PageObject* PageObj, const CFX_AffineMatrix* pObj2Device);
     void			ProcessObjectNoClip(const CPDF_PageObject* PageObj, const CFX_AffineMatrix* pObj2Device);
     void			DrawObjWithBackground(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL         DrawObjWithBlend(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			ProcessPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device);
-    void			ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, FX_BOOL& bStroke);
-    void			DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, FX_BOOL bStroke);
-    void			DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke);
-    void			DrawShadingPattern(CPDF_ShadingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke);
-    FX_BOOL			SelectClipPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke);
-    FX_BOOL			ProcessImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			OutputBitmapAlpha(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pImage2Device);
-    FX_BOOL			OutputImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pImage2Device);
-    FX_BOOL			OutputDIBSource(const CFX_DIBSource* pOutputBitmap, FX_ARGB fill_argb, int bitmap_alpha,
+    bool         DrawObjWithBlend(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device);
+    bool			ProcessPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device);
+    void			ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, bool& bStroke);
+    void			DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, bool bStroke);
+    void			DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke);
+    void			DrawShadingPattern(CPDF_ShadingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke);
+    bool			SelectClipPath(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, bool bStroke);
+    bool			ProcessImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pObj2Device);
+    bool			OutputBitmapAlpha(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pImage2Device);
+    bool			OutputImage(CPDF_ImageObject* pImageObj, const CFX_AffineMatrix* pImage2Device);
+    bool			OutputDIBSource(const CFX_DIBSource* pOutputBitmap, FX_ARGB fill_argb, int bitmap_alpha,
                                     const CFX_AffineMatrix* pImage2Device, CPDF_ImageCache* pImageCache, FX_DWORD flags);
     void			CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, int left, int top, FX_ARGB mask_argb,
                                       int bitmap_alpha, int blend_mode, int bIsolated);
-    FX_BOOL			ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device);
+    bool			ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device);
     void			DrawShading(CPDF_ShadingPattern* pPattern, CFX_AffineMatrix* pMatrix, FX_RECT& clip_rect,
-                                int alpha, FX_BOOL bAlphaMode);
-    FX_BOOL			ProcessType3Text(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			ProcessText(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device, CFX_PathData* pClippingPath);
+                                int alpha, bool bAlphaMode);
+    bool			ProcessType3Text(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device);
+    bool			ProcessText(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device, CFX_PathData* pClippingPath);
     void			DrawTextPathWithPattern(const CPDF_TextObject* textobj, const CFX_AffineMatrix* pObj2Device,
                                             CPDF_Font* pFont, FX_FLOAT font_size,
-                                            const CFX_AffineMatrix* pTextMatrix, FX_BOOL bFill, FX_BOOL bStroke);
-    FX_BOOL			ProcessForm(CPDF_FormObject* pFormObj, const CFX_AffineMatrix* pObj2Device);
+                                            const CFX_AffineMatrix* pTextMatrix, bool bFill, bool bStroke);
+    bool			ProcessForm(CPDF_FormObject* pFormObj, const CFX_AffineMatrix* pObj2Device);
     CFX_DIBitmap*	GetBackdrop(const CPDF_PageObject* pObj, const FX_RECT& rect, int& left, int& top,
-                                FX_BOOL bBackAlphaRequired);
+                                bool bBackAlphaRequired);
     CFX_DIBitmap*	LoadSMask(CPDF_Dictionary* pSMaskDict, FX_RECT* pClipRect, const CFX_AffineMatrix* pMatrix);
     void			Init(CPDF_RenderContext* pParent);
     static class CPDF_Type3Cache*	GetCachedType3(CPDF_Type3Font* pFont);
-    static CPDF_GraphicStates* CloneObjStates(const CPDF_GraphicStates* pPathObj, FX_BOOL bStroke);
+    static CPDF_GraphicStates* CloneObjStates(const CPDF_GraphicStates* pPathObj, bool bStroke);
     CPDF_TransferFunc*	GetTransferFunc(CPDF_Object* pObject) const;
-    FX_ARGB			GetFillArgb(const CPDF_PageObject* pObj, FX_BOOL bType3 = FALSE) const;
+    FX_ARGB			GetFillArgb(const CPDF_PageObject* pObj, bool bType3 = false) const;
     FX_ARGB			GetStrokeArgb(const CPDF_PageObject* pObj) const;
     CPDF_RenderContext*		m_pContext;
-    FX_BOOL					m_bStopped;
+    bool					m_bStopped;
     void			DitherObjectArea(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device);
-    FX_BOOL			GetObjectClippedRect(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bLogical, FX_RECT &rect) const;
+    bool			GetObjectClippedRect(const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, bool bLogical, FX_RECT &rect) const;
     void			GetScaledMatrix(CFX_Matrix &matrix) const;
 
 protected:
@@ -175,13 +175,13 @@ protected:
     CPDF_GraphicStates		m_InitialStates;
     int						m_HalftoneLimit;
     IPDF_ObjectRenderer*	m_pObjectRenderer;
-    FX_BOOL					m_bPrint;
+    bool					m_bPrint;
     int						m_Transparency;
     int						m_DitherBits;
-    FX_BOOL					m_bDropObjects;
-    FX_BOOL					m_bStdCS;
+    bool					m_bDropObjects;
+    bool					m_bStdCS;
     FX_DWORD                m_GroupFamily;
-    FX_BOOL                 m_bLoadMask;
+    bool                 m_bLoadMask;
     CPDF_Type3Char *        m_pType3Char;
     FX_ARGB					m_T3FillColor;
     int                     m_curBlend;
@@ -194,20 +194,20 @@ public:
         m_pBitmap = NULL;
         m_pMask = NULL;
         m_MatteColor = 0;
-        m_bCached = FALSE;
+        m_bCached = false;
         m_nDownsampleWidth = 0;
         m_nDownsampleHeight = 0;
     }
 
-    FX_BOOL					Load(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE, CPDF_RenderStatus* pRenderStatus = NULL);
+    bool					Load(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false, CPDF_RenderStatus* pRenderStatus = NULL);
 
-    FX_BOOL					StartLoadImage(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, void*& LoadHandle, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE, CPDF_RenderStatus* pRenderStatus = NULL, int32_t nDownsampleWidth = 0, int32_t nDownsampleHeight = 0);
-    FX_BOOL					Continue(void* LoadHandle, IFX_Pause* pPause);
+    bool					StartLoadImage(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, void*& LoadHandle, bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false, CPDF_RenderStatus* pRenderStatus = NULL, int32_t nDownsampleWidth = 0, int32_t nDownsampleHeight = 0);
+    bool					Continue(void* LoadHandle, IFX_Pause* pPause);
     ~CPDF_ImageLoader();
     CFX_DIBSource*			m_pBitmap;
     CFX_DIBSource*			m_pMask;
     FX_DWORD				m_MatteColor;
-    FX_BOOL					m_bCached;
+    bool					m_bCached;
 protected:
     int32_t                m_nDownsampleWidth;
     int32_t                m_nDownsampleHeight;
@@ -218,8 +218,8 @@ public:
     CPDF_ProgressiveImageLoaderHandle();
     ~CPDF_ProgressiveImageLoaderHandle();
 
-    FX_BOOL			Start(CPDF_ImageLoader* pImageLoader, const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE, CPDF_RenderStatus* pRenderStatus = NULL, int32_t nDownsampleWidth = 0, int32_t nDownsampleHeight = 0);
-    FX_BOOL			Continue(IFX_Pause* pPause);
+    bool			Start(CPDF_ImageLoader* pImageLoader, const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false, CPDF_RenderStatus* pRenderStatus = NULL, int32_t nDownsampleWidth = 0, int32_t nDownsampleHeight = 0);
+    bool			Continue(IFX_Pause* pPause);
 protected:
     CPDF_ImageLoader*	m_pImageLoader;
     CPDF_PageRenderCache* m_pCache;
@@ -233,10 +233,10 @@ class CPDF_ImageRenderer : public IPDF_ObjectRenderer
 public:
     CPDF_ImageRenderer();
     ~CPDF_ImageRenderer();
-    FX_BOOL		Start(CPDF_RenderStatus* pStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStdCS, int blendType = FXDIB_BLEND_NORMAL);
-    FX_BOOL		Start(CPDF_RenderStatus* pStatus, const CFX_DIBSource* pDIBSource, FX_ARGB bitmap_argb,
-                      int bitmap_alpha, const CFX_AffineMatrix* pImage2Device, FX_DWORD flags, FX_BOOL bStdCS, int blendType = FXDIB_BLEND_NORMAL);
-    FX_BOOL		Continue(IFX_Pause* pPause);
+    bool		Start(CPDF_RenderStatus* pStatus, const CPDF_PageObject* pObj, const CFX_AffineMatrix* pObj2Device, bool bStdCS, int blendType = FXDIB_BLEND_NORMAL);
+    bool		Start(CPDF_RenderStatus* pStatus, const CFX_DIBSource* pDIBSource, FX_ARGB bitmap_argb,
+                      int bitmap_alpha, const CFX_AffineMatrix* pImage2Device, FX_DWORD flags, bool bStdCS, int blendType = FXDIB_BLEND_NORMAL);
+    bool		Continue(IFX_Pause* pPause);
 protected:
     CPDF_RenderStatus*	m_pRenderStatus;
     CPDF_ImageObject*	m_pImageObject;
@@ -247,7 +247,7 @@ protected:
     const CFX_DIBSource*		m_pDIBSource;
     CFX_DIBitmap*		m_pClone;
     int					m_BitmapAlpha;
-    FX_BOOL				m_bPatternColor;
+    bool				m_bPatternColor;
     CPDF_Pattern*		m_pPattern;
     FX_ARGB				m_FillArgb;
     FX_DWORD			m_Flags;
@@ -255,21 +255,21 @@ protected:
     CFX_ImageTransformer*	m_pTransformer;
     void*			m_DeviceHandle;
     void*           m_LoadHandle;
-    FX_BOOL				m_bStdCS;
+    bool				m_bStdCS;
     int					m_BlendType;
-    FX_BOOL				StartBitmapAlpha();
-    FX_BOOL				StartDIBSource();
-    FX_BOOL				StartRenderDIBSource();
-    FX_BOOL				StartLoadDIBSource();
-    FX_BOOL				DrawMaskedImage();
-    FX_BOOL				DrawPatternImage(const CFX_Matrix* pObj2Device);
+    bool				StartBitmapAlpha();
+    bool				StartDIBSource();
+    bool				StartRenderDIBSource();
+    bool				StartLoadDIBSource();
+    bool				DrawMaskedImage();
+    bool				DrawPatternImage(const CFX_Matrix* pObj2Device);
 };
 class CPDF_ScaledRenderBuffer
 {
 public:
     CPDF_ScaledRenderBuffer();
     ~CPDF_ScaledRenderBuffer();
-    FX_BOOL				Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
+    bool				Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
                                    const CPDF_PageObject* pObj, const CPDF_RenderOptions *pOptions = NULL, int max_dpi = 0);
     CFX_RenderDevice*	GetDevice()
     {
@@ -294,13 +294,13 @@ class CPDF_QuickStretcher
 public:
     CPDF_QuickStretcher();
     ~CPDF_QuickStretcher();
-    FX_BOOL		Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix* pImage2Device, const FX_RECT* pClipBox);
-    FX_BOOL		Continue(IFX_Pause* pPause);
+    bool		Start(CPDF_ImageObject* pImageObj, CFX_AffineMatrix* pImage2Device, const FX_RECT* pClipBox);
+    bool		Continue(IFX_Pause* pPause);
     CFX_DIBitmap*	m_pBitmap;
     int			m_ResultLeft, m_ResultTop, m_ClipLeft, m_ClipTop;
     int			m_DestWidth, m_DestHeight, m_ResultWidth, m_ResultHeight;
     int			m_Bpp, m_SrcWidth, m_SrcHeight;
-    FX_BOOL		m_bFlipX, m_bFlipY;
+    bool		m_bFlipX, m_bFlipY;
     CPDF_ColorSpace*	m_pCS;
     ICodec_ScanlineDecoder*	m_pDecoder;
     CPDF_StreamAcc m_StreamAcc;
@@ -311,7 +311,7 @@ class CPDF_DeviceBuffer
 public:
     CPDF_DeviceBuffer();
     ~CPDF_DeviceBuffer();
-    FX_BOOL				Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
+    bool				Initialize(CPDF_RenderContext* pContext, CFX_RenderDevice* pDevice, FX_RECT* pRect,
                                    const CPDF_PageObject* pObj, int max_dpi = 0);
     void				OutputToDevice();
     CFX_DIBitmap*		GetBitmap() const
@@ -337,8 +337,8 @@ public:
     ~CPDF_ImageCache();
     void				ClearImageData();
     void				Reset(const CFX_DIBitmap* pBitmap);
-    FX_BOOL				GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
-                                        FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE,
+    bool				GetCachedBitmap(CFX_DIBSource*& pBitmap, CFX_DIBSource*& pMask, FX_DWORD& MatteColor, CPDF_Dictionary* pPageResources,
+                                        bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false,
                                         CPDF_RenderStatus* pRenderStatus = NULL, int32_t downsampleWidth = 0, int32_t downsampleHeight = 0);
     FX_DWORD			EstimateSize() const
     {
@@ -359,8 +359,8 @@ public:
     int					m_dwTimeCount;
 public:
     int					StartGetCachedBitmap(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources,
-            FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0,
-            FX_BOOL bLoadMask = FALSE, CPDF_RenderStatus* pRenderStatus = NULL, int32_t downsampleWidth = 0, int32_t downsampleHeight = 0);
+            bool bStdCS = false, FX_DWORD GroupFamily = 0,
+            bool bLoadMask = false, CPDF_RenderStatus* pRenderStatus = NULL, int32_t downsampleWidth = 0, int32_t downsampleHeight = 0);
     int					Continue(IFX_Pause* pPause);
     int 				ContinueGetCachedBitmap();
     CFX_DIBSource*		DetachBitmap();
@@ -388,23 +388,23 @@ class CPDF_DIBSource : public CFX_DIBSource
 public:
     CPDF_DIBSource();
     virtual ~CPDF_DIBSource();
-    FX_BOOL				Load(CPDF_Document* pDoc, const CPDF_Stream* pStream,
+    bool				Load(CPDF_Document* pDoc, const CPDF_Stream* pStream,
                              CPDF_DIBSource** ppMask, FX_DWORD* pMatteColor,
                              CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources,
-                             FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE);
-    virtual FX_BOOL		SkipToScanline(int line, IFX_Pause* pPause) const;
+                             bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false);
+    virtual bool		SkipToScanline(int line, IFX_Pause* pPause) const;
     virtual	uint8_t*	GetBuffer() const;
     virtual const uint8_t*	GetScanline(int line) const;
     virtual void		DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-                                           int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const;
+                                           int dest_width, bool bFlipX, int clip_left, int clip_width) const;
     virtual void		SetDownSampleSize(int dest_width, int dest_height) const;
     CFX_DIBitmap*		GetBitmap() const;
     void				ReleaseBitmap(CFX_DIBitmap*) const;
     void				ClearImageData();
 public:
-    int					StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* pStream, FX_BOOL bHasMask,
+    int					StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* pStream, bool bHasMask,
                                            CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources,
-                                           FX_BOOL bStdCS = FALSE, FX_DWORD GroupFamily = 0, FX_BOOL bLoadMask = FALSE);
+                                           bool bStdCS = false, FX_DWORD GroupFamily = 0, bool bLoadMask = false);
     int					ContinueLoadDIBSource(IFX_Pause* pPause);
     int					StratLoadMask();
     int					StartLoadMaskDIB();
@@ -415,13 +415,13 @@ public:
     FX_DWORD			m_MatteColor;
     void*			m_pJbig2Context;
     CPDF_StreamAcc*		m_pGlobalStream;
-    FX_BOOL				m_bStdCS;
+    bool				m_bStdCS;
     int					m_Status;
     CPDF_Object*		m_pMaskStream;
-    FX_BOOL				m_bHasMask;
+    bool				m_bHasMask;
 protected:
-    FX_BOOL				LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources);
-    DIB_COMP_DATA*      GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, FX_BOOL& bColorKey);
+    bool				LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources);
+    DIB_COMP_DATA*      GetDecodeAndMaskArray(bool& bDefaultDecode, bool& bColorKey);
     CPDF_DIBSource*		LoadMask(FX_DWORD& MatteColor);
     CPDF_DIBSource*		LoadMaskDIB(CPDF_Stream* pMask);
     void				LoadJpxBitmap();
@@ -439,11 +439,11 @@ protected:
     FX_DWORD			m_bpc_orig;
     FX_DWORD			m_nComponents;
     FX_DWORD			m_GroupFamily;
-    FX_BOOL				m_bLoadMask;
-    FX_BOOL				m_bDefaultDecode;
-    FX_BOOL				m_bImageMask;
-    FX_BOOL				m_bDoBpcCheck;
-    FX_BOOL				m_bColorKey;
+    bool				m_bLoadMask;
+    bool				m_bDefaultDecode;
+    bool				m_bImageMask;
+    bool				m_bDoBpcCheck;
+    bool				m_bColorKey;
     DIB_COMP_DATA*		m_pCompData;
     uint8_t*			m_pLineBuf;
     uint8_t*			m_pMaskedLine;
diff --git a/core/src/fpdfdoc/doc_action.cpp b/core/src/fpdfdoc/doc_action.cpp
index 851b2d6709..e7a339ce36 100644
--- a/core/src/fpdfdoc/doc_action.cpp
+++ b/core/src/fpdfdoc/doc_action.cpp
@@ -289,10 +289,10 @@ const FX_CHAR* g_sAATypes[] = {"E", "X", "D", "U", "Fo", "Bl", "PO", "PC", "PV",
                                "WC", "WS", "DS", "WP", "DP",
                                ""
                               };
-FX_BOOL CPDF_AAction::ActionExist(AActionType eType) const
+bool CPDF_AAction::ActionExist(AActionType eType) const
 {
     if (m_pDict == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pDict->KeyExist(g_sAATypes[(int)eType]);
 }
diff --git a/core/src/fpdfdoc/doc_annot.cpp b/core/src/fpdfdoc/doc_annot.cpp
index 0a746190c0..5430079abc 100644
--- a/core/src/fpdfdoc/doc_annot.cpp
+++ b/core/src/fpdfdoc/doc_annot.cpp
@@ -22,7 +22,7 @@ CPDF_AnnotList::CPDF_AnnotList(CPDF_Page* pPage)
     }
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     CPDF_Dictionary* pAcroForm = pRoot->GetDict("AcroForm");
-    FX_BOOL bRegenerateAP = pAcroForm && pAcroForm->GetBoolean("NeedAppearances");
+    bool bRegenerateAP = pAcroForm && pAcroForm->GetBoolean("NeedAppearances");
     for (FX_DWORD i = 0; i < pAnnots->GetCount(); ++i) {
         CPDF_Dictionary* pDict = (CPDF_Dictionary*)pAnnots->GetElementValue(i);
         if (pDict == NULL || pDict->GetType() != PDFOBJ_DICTIONARY) {
@@ -55,12 +55,12 @@ CPDF_AnnotList::~CPDF_AnnotList()
     }
 }
 void CPDF_AnnotList::DisplayPass(const CPDF_Page* pPage, CFX_RenderDevice* pDevice,
-                                 CPDF_RenderContext* pContext, FX_BOOL bPrinting, CFX_AffineMatrix* pMatrix,
-                                 FX_BOOL bWidgetPass, CPDF_RenderOptions* pOptions, FX_RECT* clip_rect)
+                                 CPDF_RenderContext* pContext, bool bPrinting, CFX_AffineMatrix* pMatrix,
+                                 bool bWidgetPass, CPDF_RenderOptions* pOptions, FX_RECT* clip_rect)
 {
     for (int i = 0; i < m_AnnotList.GetSize(); ++i) {
         CPDF_Annot* pAnnot = (CPDF_Annot*)m_AnnotList[i];
-        FX_BOOL bWidget = pAnnot->GetSubType() == "Widget";
+        bool bWidget = pAnnot->GetSubType() == "Widget";
         if ((bWidgetPass && !bWidget) || (!bWidgetPass && bWidget)) {
             continue;
         }
@@ -103,24 +103,24 @@ void CPDF_AnnotList::DisplayPass(const CPDF_Page* pPage, CFX_RenderDevice* pDevi
 }
 void CPDF_AnnotList::DisplayAnnots(const CPDF_Page* pPage, CFX_RenderDevice* pDevice,
                                    CFX_AffineMatrix* pUser2Device,
-                                   FX_BOOL bShowWidget, CPDF_RenderOptions* pOptions)
+                                   bool bShowWidget, CPDF_RenderOptions* pOptions)
 {
     FX_RECT clip_rect;
     if (pDevice) {
         clip_rect = pDevice->GetClipBox();
     }
-    FX_BOOL bPrinting = pDevice->GetDeviceClass() == FXDC_PRINTER || (pOptions && (pOptions->m_Flags & RENDER_PRINTPREVIEW));
+    bool bPrinting = pDevice->GetDeviceClass() == FXDC_PRINTER || (pOptions && (pOptions->m_Flags & RENDER_PRINTPREVIEW));
     DisplayAnnots(pPage, pDevice, NULL, bPrinting, pUser2Device, bShowWidget ? 3 : 1, pOptions, &clip_rect);
 }
 void CPDF_AnnotList::DisplayAnnots(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, CPDF_RenderContext* pContext,
-                                   FX_BOOL bPrinting, CFX_AffineMatrix* pUser2Device, FX_DWORD dwAnnotFlags,
+                                   bool bPrinting, CFX_AffineMatrix* pUser2Device, FX_DWORD dwAnnotFlags,
                                    CPDF_RenderOptions* pOptions, FX_RECT* pClipRect)
 {
     if (dwAnnotFlags & 0x01) {
-        DisplayPass(pPage, pDevice, pContext, bPrinting, pUser2Device, FALSE, pOptions, pClipRect);
+        DisplayPass(pPage, pDevice, pContext, bPrinting, pUser2Device, false, pOptions, pClipRect);
     }
     if (dwAnnotFlags & 0x02) {
-        DisplayPass(pPage, pDevice, pContext, bPrinting, pUser2Device, TRUE, pOptions, pClipRect);
+        DisplayPass(pPage, pDevice, pContext, bPrinting, pUser2Device, true, pOptions, pClipRect);
     }
 }
 int CPDF_AnnotList::GetIndex(CPDF_Annot* pAnnot)
@@ -246,28 +246,28 @@ static CPDF_Form* FPDFDOC_Annot_GetMatrix(const CPDF_Page* pPage, CPDF_Annot* pA
     matrix.Concat(*pUser2Device);
     return pForm;
 }
-FX_BOOL CPDF_Annot::DrawAppearance(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device,
+bool CPDF_Annot::DrawAppearance(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device,
                                    AppearanceMode mode, const CPDF_RenderOptions* pOptions)
 {
     CFX_Matrix matrix;
     CPDF_Form* pForm = FPDFDOC_Annot_GetMatrix(pPage, this, mode, pUser2Device, matrix);
     if (!pForm) {
-        return FALSE;
+        return false;
     }
     CPDF_RenderContext context;
     context.Create((CPDF_Page*)pPage);
     context.DrawObjectList(pDevice, pForm, &matrix, pOptions);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_Annot::DrawInContext(const CPDF_Page* pPage, const CPDF_RenderContext* pContext, const CFX_AffineMatrix* pUser2Device, AppearanceMode mode)
+bool CPDF_Annot::DrawInContext(const CPDF_Page* pPage, const CPDF_RenderContext* pContext, const CFX_AffineMatrix* pUser2Device, AppearanceMode mode)
 {
     CFX_Matrix matrix;
     CPDF_Form* pForm = FPDFDOC_Annot_GetMatrix(pPage, this, mode, pUser2Device, matrix);
     if (!pForm) {
-        return FALSE;
+        return false;
     }
     ((CPDF_RenderContext*)pContext)->AppendObjectList(pForm, &matrix);
-    return TRUE;
+    return true;
 }
 void CPDF_Annot::DrawBorder(CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device, const CPDF_RenderOptions* pOptions)
 {
@@ -278,7 +278,7 @@ void CPDF_Annot::DrawBorder(CFX_RenderDevice* pDevice, const CFX_AffineMatrix* p
     if (annot_flags & ANNOTFLAG_HIDDEN) {
         return;
     }
-    FX_BOOL bPrinting = pDevice->GetDeviceClass() == FXDC_PRINTER || (pOptions && (pOptions->m_Flags & RENDER_PRINTPREVIEW));
+    bool bPrinting = pDevice->GetDeviceClass() == FXDC_PRINTER || (pOptions && (pOptions->m_Flags & RENDER_PRINTPREVIEW));
     if (bPrinting && (annot_flags & ANNOTFLAG_PRINT) == 0) {
         return;
     }
diff --git a/core/src/fpdfdoc/doc_ap.cpp b/core/src/fpdfdoc/doc_ap.cpp
index f94a4d60e0..4f3f178007 100644
--- a/core/src/fpdfdoc/doc_ap.cpp
+++ b/core/src/fpdfdoc/doc_ap.cpp
@@ -8,10 +8,10 @@
 #include "../../include/fpdfdoc/fpdf_vt.h"
 #include "pdf_vt.h"
 #include "../../include/fpdfdoc/fpdf_ap.h"
-FX_BOOL FPDF_GenerateAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
+bool FPDF_GenerateAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
 {
     if (!pAnnotDict || pAnnotDict->GetConstString("Subtype") != FX_BSTRC("Widget")) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString field_type = FPDF_GetFieldAttr(pAnnotDict, "FT")->GetString();
     FX_DWORD flags = FPDF_GetFieldAttr(pAnnotDict, "Ff")? FPDF_GetFieldAttr(pAnnotDict, "Ff")->GetInteger() : 0;
@@ -34,7 +34,7 @@ FX_BOOL FPDF_GenerateAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
             }
         }
     }
-    return FALSE;
+    return false;
 }
 class CPVT_FontMap : public IPVT_FontMap
 {
@@ -154,12 +154,12 @@ int32_t CPVT_Provider::GetWordFontIndex(FX_WORD word, int32_t charset, int32_t n
         }
     return -1;
 }
-FX_BOOL CPVT_Provider::IsLatinWord(FX_WORD word)
+bool CPVT_Provider::IsLatinWord(FX_WORD word)
 {
     if ((word >= 0x61 && word <= 0x7A) || (word >= 0x41 && word <= 0x5A) || word == 0x2D || word == 0x27) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 int32_t CPVT_Provider::GetDefaultFontIndex()
 {
@@ -244,14 +244,14 @@ static CPVT_Color ParseColor(const CPDF_Array & array)
     }
     return rt;
 }
-static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict, const int32_t & nWidgetType)
+static bool GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict, const int32_t & nWidgetType)
 {
     CPDF_Dictionary* pFormDict = NULL;
     if (CPDF_Dictionary * pRootDict = pDoc->GetRoot()) {
         pFormDict = pRootDict->GetDict("AcroForm");
     }
     if (!pFormDict) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString DA;
     if (CPDF_Object* pDAObj = FPDF_GetFieldAttr(pAnnotDict, "DA")) {
@@ -261,23 +261,23 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
         DA = pFormDict->GetString("DA");
     }
     if (DA.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CPDF_SimpleParser syntax(DA);
     syntax.FindTagParam("Tf", 2);
     CFX_ByteString sFontName = syntax.GetWord();
     sFontName = PDF_NameDecode(sFontName);
     if (sFontName.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT fFontSize = FX_atof(syntax.GetWord());
     CPVT_Color crText = ParseColor(DA);
-    FX_BOOL bUseFormRes = FALSE;
+    bool bUseFormRes = false;
     CPDF_Dictionary * pFontDict = NULL;
     CPDF_Dictionary* pDRDict = pAnnotDict->GetDict(FX_BSTRC("DR"));
     if (pDRDict == NULL) {
         pDRDict = pFormDict->GetDict(FX_BSTRC("DR"));
-        bUseFormRes = TRUE;
+        bUseFormRes = true;
     }
     CPDF_Dictionary * pDRFontDict = NULL;
     if (pDRDict && (pDRFontDict = pDRDict->GetDict("Font"))) {
@@ -291,12 +291,12 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
         }
     }
     if (!pDRFontDict) {
-        return FALSE;
+        return false;
     }
     if (!pFontDict) {
         pFontDict = CPDF_Dictionary::Create();
         if (pFontDict == NULL) {
-            return FALSE;
+            return false;
         }
         pFontDict->SetAtName(FX_BSTRC("Type"), "Font");
         pFontDict->SetAtName(FX_BSTRC("Subtype"), "Type1");
@@ -307,7 +307,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
     }
     CPDF_Font* pDefFont = pDoc->LoadFont(pFontDict);
     if (!pDefFont) {
-        return FALSE;
+        return false;
     }
     CPDF_Rect rcAnnot = pAnnotDict->GetRect("Rect");
     int32_t nRotate = 0;
@@ -378,7 +378,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
         }
     }
     CFX_ByteTextBuf sAppStream;
-    CFX_ByteString sBG = CPVT_GenerateAP::GenerateColorAP(crBG, TRUE);
+    CFX_ByteString sBG = CPVT_GenerateAP::GenerateColorAP(crBG, true);
     if (sBG.GetLength() > 0) {
         sAppStream << "q\n" << sBG << rcBBox.left << " " << rcBBox.bottom << " "
                    << rcBBox.Width() << " " << rcBBox.Height() << " re f\n" << "Q\n";
@@ -395,7 +395,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
     if (pAPDict == NULL) {
         pAPDict = CPDF_Dictionary::Create();
         if (pAPDict == NULL) {
-            return FALSE;
+            return false;
         }
         pAnnotDict->SetAt("AP", pAPDict);
     }
@@ -403,7 +403,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
     if (pNormalStream == NULL) {
         pNormalStream = CPDF_Stream::Create(NULL, 0, NULL);
         if (pNormalStream == NULL) {
-            return FALSE;
+            return false;
         }
         int32_t objnum = pDoc->AddIndirectObject(pNormalStream);
         pAnnotDict->GetDict("AP")->SetAtReference("N", pDoc, objnum);
@@ -418,7 +418,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
             if (!pStreamResFontList) {
                 pStreamResFontList = CPDF_Dictionary::Create();
                 if (pStreamResFontList == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 pStreamResList->SetAt("Font", pStreamResFontList);
             }
@@ -443,21 +443,21 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                 vt.SetPlateRect(rcBody);
                 vt.SetAlignment(nAlign);
                 if (IsFloatZero(fFontSize)) {
-                    vt.SetAutoFontSize(TRUE);
+                    vt.SetAutoFontSize(true);
                 } else {
                     vt.SetFontSize(fFontSize);
                 }
-                FX_BOOL bMultiLine = (dwFlags >> 12) & 1;
+                bool bMultiLine = (dwFlags >> 12) & 1;
                 if (bMultiLine) {
-                    vt.SetMultiLine(TRUE);
-                    vt.SetAutoReturn(TRUE);
+                    vt.SetMultiLine(true);
+                    vt.SetAutoReturn(true);
                 }
                 FX_WORD subWord = 0;
                 if ((dwFlags >> 13) & 1) {
                     subWord = '*';
                     vt.SetPasswordChar(subWord);
                 }
-                FX_BOOL bCharArray = (dwFlags >> 24) & 1;
+                bool bCharArray = (dwFlags >> 24) & 1;
                 if (bCharArray) {
                     vt.SetCharArray(dwMaxLen);
                 } else {
@@ -479,7 +479,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                         sAppStream << rcBody.left << " " << rcBody.bottom << " "
                                    << rcBody.Width() << " " << rcBody.Height() << " re\nW\nn\n";
                     }
-                    sAppStream << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, TRUE) << sBody << "ET\n" << "Q\nEMC\n";
+                    sAppStream << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, true) << sBody << "ET\n" << "Q\nEMC\n";
                 }
             }
             break;
@@ -497,7 +497,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                 rcEdit.Normalize();
                 vt.SetPlateRect(rcEdit);
                 if (IsFloatZero(fFontSize)) {
-                    vt.SetAutoFontSize(TRUE);
+                    vt.SetAutoFontSize(true);
                 } else {
                     vt.SetFontSize(fFontSize);
                 }
@@ -506,14 +506,14 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                 vt.RearrangeAll();
                 CPDF_Rect rcContent = vt.GetContentRect();
                 CPDF_Point ptOffset = CPDF_Point(0.0f, (rcContent.Height() - rcEdit.Height()) / 2.0f);
-                CFX_ByteString sEdit = CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), ptOffset, TRUE, 0);
+                CFX_ByteString sEdit = CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), ptOffset, true, 0);
                 if (sEdit.GetLength() > 0) {
                     sAppStream << "/Tx BMC\n" << "q\n";
                     sAppStream << rcEdit.left << " " << rcEdit.bottom << " "
                                << rcEdit.Width() << " " << rcEdit.Height() << " re\nW\nn\n";
-                    sAppStream << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, TRUE) << sEdit << "ET\n" << "Q\nEMC\n";
+                    sAppStream << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, true) << sEdit << "ET\n" << "Q\nEMC\n";
                 }
-                CFX_ByteString sButton = CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_RGB, 220.0f / 255.0f, 220.0f / 255.0f, 220.0f / 255.0f), TRUE);
+                CFX_ByteString sButton = CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_RGB, 220.0f / 255.0f, 220.0f / 255.0f, 220.0f / 255.0f), true);
                 if (sButton.GetLength() > 0 && !rcButton.IsEmpty()) {
                     sAppStream << "q\n" << sButton;
                     sAppStream << rcButton.left << " " << rcButton.bottom << " "
@@ -555,11 +555,11 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                             } else if (pOpt->GetType() == PDFOBJ_ARRAY) {
                                 swItem = ((CPDF_Array*)pOpt)->GetElementValue(1)->GetUnicodeText();
                             }
-                            FX_BOOL bSelected = FALSE;
+                            bool bSelected = false;
                             if (pSels) {
                                 for (FX_DWORD s = 0, ssz = pSels->GetCount(); s < ssz; s++) {
                                     if (i == pSels->GetInteger(s)) {
-                                        bSelected = TRUE;
+                                        bSelected = true;
                                         break;
                                     }
                                 }
@@ -578,11 +578,11 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                             FX_FLOAT fItemHeight = vt.GetContentRect().Height();
                             if (bSelected) {
                                 CPDF_Rect rcItem = CPDF_Rect(rcBody.left, fy - fItemHeight, rcBody.right, fy);
-                                sBody << "q\n" << CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_RGB, 0, 51.0f / 255.0f, 113.0f / 255.0f), TRUE)
+                                sBody << "q\n" << CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_RGB, 0, 51.0f / 255.0f, 113.0f / 255.0f), true)
                                       << rcItem.left << " " << rcItem.bottom << " " << rcItem.Width() << " " << rcItem.Height() << " re f\n" << "Q\n";
-                                sBody << "BT\n" << CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_GRAY, 1), TRUE) << CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), CPDF_Point(0.0f, fy), TRUE, 0) << "ET\n";
+                                sBody << "BT\n" << CPVT_GenerateAP::GenerateColorAP(CPVT_Color(CT_GRAY, 1), true) << CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), CPDF_Point(0.0f, fy), true, 0) << "ET\n";
                             } else {
-                                sBody << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, TRUE) << CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), CPDF_Point(0.0f, fy), TRUE, 0) << "ET\n";
+                                sBody << "BT\n" << CPVT_GenerateAP::GenerateColorAP(crText, true) << CPVT_GenerateAP::GenerateEditAP(&map, vt.GetIterator(), CPDF_Point(0.0f, fy), true, 0) << "ET\n";
                             }
                             fy -= fItemHeight;
                         }
@@ -598,7 +598,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
             break;
     }
     if (pNormalStream) {
-        pNormalStream->SetData((uint8_t*)sAppStream.GetBuffer(), sAppStream.GetSize(), FALSE, FALSE);
+        pNormalStream->SetData((uint8_t*)sAppStream.GetBuffer(), sAppStream.GetSize(), false, false);
         pStreamDict = pNormalStream->GetDict();
         if (pStreamDict) {
             pStreamDict->SetAtMatrix("Matrix", matrix);
@@ -609,7 +609,7 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
                 if (!pStreamResFontList) {
                     pStreamResFontList = CPDF_Dictionary::Create();
                     if (pStreamResFontList == NULL) {
-                        return FALSE;
+                        return false;
                     }
                     pStreamResList->SetAt("Font", pStreamResFontList);
                 }
@@ -622,21 +622,21 @@ static FX_BOOL GenerateWidgetAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPVT_GenerateAP::GenerateTextFieldAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
+bool CPVT_GenerateAP::GenerateTextFieldAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
 {
     return GenerateWidgetAP(pDoc, pAnnotDict, 0);
 }
-FX_BOOL CPVT_GenerateAP::GenerateComboBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
+bool CPVT_GenerateAP::GenerateComboBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
 {
     return GenerateWidgetAP(pDoc, pAnnotDict, 1);
 }
-FX_BOOL CPVT_GenerateAP::GenerateListBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
+bool CPVT_GenerateAP::GenerateListBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict)
 {
     return GenerateWidgetAP(pDoc, pAnnotDict, 2);
 }
-CFX_ByteString CPVT_GenerateAP::GenerateEditAP(IPVT_FontMap * pFontMap, IPDF_VariableText_Iterator* pIterator, const CPDF_Point & ptOffset, FX_BOOL bContinuous, FX_WORD SubWord, const CPVT_WordRange * pVisible)
+CFX_ByteString CPVT_GenerateAP::GenerateEditAP(IPVT_FontMap * pFontMap, IPDF_VariableText_Iterator* pIterator, const CPDF_Point & ptOffset, bool bContinuous, FX_WORD SubWord, const CPVT_WordRange * pVisible)
 {
     CFX_ByteTextBuf sEditStream, sLineStream, sWords;
     CPDF_Point ptOld(0.0f, 0.0f), ptNew(0.0f, 0.0f);
@@ -726,7 +726,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
         switch (nStyle) {
             default:
             case PBS_SOLID:
-                sColor = GenerateColorAP(color, TRUE);
+                sColor = GenerateColorAP(color, true);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fLeft << " " << fBottom << " " << fRight - fLeft << " " << fTop - fBottom << " re\n";
@@ -736,7 +736,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
                 }
                 break;
             case PBS_DASH:
-                sColor = GenerateColorAP(color, FALSE);
+                sColor = GenerateColorAP(color, false);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fWidth << " w" << " [" << dash.nDash << " " << dash.nGap << "] " << dash.nPhase << " d\n";
@@ -749,7 +749,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
                 break;
             case PBS_BEVELED:
             case PBS_INSET:
-                sColor = GenerateColorAP(crLeftTop, TRUE);
+                sColor = GenerateColorAP(crLeftTop, true);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fLeft + fHalfWidth << " " << fBottom + fHalfWidth << " m\n";
@@ -759,7 +759,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
                     sAppStream << fLeft + fHalfWidth * 2 << " " << fTop - fHalfWidth * 2 << " l\n";
                     sAppStream << fLeft + fHalfWidth * 2 << " " << fBottom + fHalfWidth * 2 << " l f\n";
                 }
-                sColor = GenerateColorAP(crRightBottom, TRUE);
+                sColor = GenerateColorAP(crRightBottom, true);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fRight - fHalfWidth << " " <<	fTop - fHalfWidth << " m\n";
@@ -769,7 +769,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
                     sAppStream << fRight - fHalfWidth * 2 << " " << fBottom + fHalfWidth * 2 << " l\n";
                     sAppStream << fRight - fHalfWidth * 2 << " " << fTop - fHalfWidth * 2 << " l f\n";
                 }
-                sColor = GenerateColorAP(color, TRUE);
+                sColor = GenerateColorAP(color, true);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fLeft << " " << fBottom << " " <<	fRight - fLeft << " " << fTop - fBottom << " re\n";
@@ -778,7 +778,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
                 }
                 break;
             case PBS_UNDERLINED:
-                sColor = GenerateColorAP(color, FALSE);
+                sColor = GenerateColorAP(color, false);
                 if (sColor.GetLength() > 0) {
                     sAppStream << sColor;
                     sAppStream << fWidth << " w\n";
@@ -790,7 +790,7 @@ CFX_ByteString CPVT_GenerateAP::GenerateBorderAP(const CPDF_Rect & rect, FX_FLOA
     }
     return sAppStream.GetByteString();
 }
-CFX_ByteString CPVT_GenerateAP::GenerateColorAP(const CPVT_Color & color, const FX_BOOL & bFillOrStroke)
+CFX_ByteString CPVT_GenerateAP::GenerateColorAP(const CPVT_Color & color, const bool & bFillOrStroke)
 {
     CFX_ByteTextBuf sColorStream;
     switch (color.nColorType) {
diff --git a/core/src/fpdfdoc/doc_basic.cpp b/core/src/fpdfdoc/doc_basic.cpp
index 3ba109b016..647b7cb718 100644
--- a/core/src/fpdfdoc/doc_basic.cpp
+++ b/core/src/fpdfdoc/doc_basic.cpp
@@ -313,10 +313,10 @@ static CFX_WideString FILESPEC_DecodeFileName(const CFX_WideStringC& filepath)
     return filepath;
 #endif
 }
-FX_BOOL CPDF_FileSpec::GetFileName(CFX_WideString &csFileName) const
+bool CPDF_FileSpec::GetFileName(CFX_WideString &csFileName) const
 {
     if (m_pObj == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pObj->GetType() == PDFOBJ_DICTIONARY) {
         CPDF_Dictionary* pDict = (CPDF_Dictionary*)m_pObj;
@@ -325,7 +325,7 @@ FX_BOOL CPDF_FileSpec::GetFileName(CFX_WideString &csFileName) const
             csFileName = CFX_WideString::FromLocal(pDict->GetString(FX_BSTRC("F")));
         }
         if (pDict->GetString(FX_BSTRC("FS")) == FX_BSTRC("URL")) {
-            return TRUE;
+            return true;
         }
         if (csFileName.IsEmpty()) {
             if (pDict->KeyExist(FX_BSTRC("DOS"))) {
@@ -335,14 +335,14 @@ FX_BOOL CPDF_FileSpec::GetFileName(CFX_WideString &csFileName) const
             } else if (pDict->KeyExist(FX_BSTRC("Unix"))) {
                 csFileName = CFX_WideString::FromLocal(pDict->GetString(FX_BSTRC("Unix")));
             } else {
-                return FALSE;
+                return false;
             }
         }
     } else {
         csFileName = CFX_WideString::FromLocal(m_pObj->GetString());
     }
     csFileName = FILESPEC_DecodeFileName(csFileName);
-    return TRUE;
+    return true;
 }
 CPDF_FileSpec::CPDF_FileSpec()
 {
@@ -351,13 +351,13 @@ CPDF_FileSpec::CPDF_FileSpec()
         ((CPDF_Dictionary*)m_pObj)->SetAtName(FX_BSTRC("Type"), FX_BSTRC("Filespec"));
     }
 }
-FX_BOOL CPDF_FileSpec::IsURL() const
+bool CPDF_FileSpec::IsURL() const
 {
     if (m_pObj == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pObj->GetType() != PDFOBJ_DICTIONARY) {
-        return FALSE;
+        return false;
     }
     return ((CPDF_Dictionary*)m_pObj)->GetString(FX_BSTRC("FS")) == FX_BSTRC("URL");
 }
@@ -416,7 +416,7 @@ CPDF_Stream* CPDF_FileSpec::GetFileStream() const
     }
     return NULL;
 }
-static void FPDFDOC_FILESPEC_SetFileName(CPDF_Object *pObj, const CFX_WideStringC& wsFileName, FX_BOOL bURL)
+static void FPDFDOC_FILESPEC_SetFileName(CPDF_Object *pObj, const CFX_WideStringC& wsFileName, bool bURL)
 {
     ASSERT(pObj != NULL);
     CFX_WideString wsStr;
@@ -434,7 +434,7 @@ static void FPDFDOC_FILESPEC_SetFileName(CPDF_Object *pObj, const CFX_WideString
         pDict->SetAtString(FX_BSTRC("UF"), PDF_EncodeText(wsStr));
     }
 }
-void CPDF_FileSpec::SetFileName(const CFX_WideStringC& wsFileName, FX_BOOL bURL)
+void CPDF_FileSpec::SetFileName(const CFX_WideStringC& wsFileName, bool bURL)
 {
     ASSERT(m_pObj != NULL);
     if (m_pObj->GetType() == PDFOBJ_DICTIONARY && bURL) {
diff --git a/core/src/fpdfdoc/doc_form.cpp b/core/src/fpdfdoc/doc_form.cpp
index 735231cc1d..6057f56437 100644
--- a/core/src/fpdfdoc/doc_form.cpp
+++ b/core/src/fpdfdoc/doc_form.cpp
@@ -241,12 +241,12 @@ CFieldTree::_Node *CFieldTree::FindNode(const CFX_WideString& full_name)
     }
     return pNode;
 }
-CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument, FX_BOOL bGenerateAP) : CFX_PrivateData()
+CPDF_InterForm::CPDF_InterForm(CPDF_Document* pDocument, bool bGenerateAP) : CFX_PrivateData()
 {
     m_pDocument = pDocument;
     m_bGenerateAP = bGenerateAP;
     m_pFormNotify = NULL;
-    m_bUpdated = FALSE;
+    m_bUpdated = false;
     m_pFieldTree = new CFieldTree;
     CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
     m_pFormDict = pRoot->GetDict("AcroForm");
@@ -280,12 +280,12 @@ CPDF_InterForm::~CPDF_InterForm()
         delete m_pFieldTree;
     }
 }
-FX_BOOL	CPDF_InterForm::m_bUpdateAP = TRUE;
-FX_BOOL CPDF_InterForm::UpdatingAPEnabled()
+bool	CPDF_InterForm::m_bUpdateAP = true;
+bool CPDF_InterForm::UpdatingAPEnabled()
 {
     return m_bUpdateAP;
 }
-void CPDF_InterForm::EnableUpdateAP(FX_BOOL bUpdateAP)
+void CPDF_InterForm::EnableUpdateAP(bool bUpdateAP)
 {
     m_bUpdateAP = bUpdateAP;
 }
@@ -328,7 +328,7 @@ CFX_ByteString CPDF_InterForm::GenerateNewResourceName(const CPDF_Dictionary* pR
     }
     int num = 0;
     CFX_ByteString bsNum;
-    while (TRUE) {
+    while (true) {
         if (!pDict->KeyExist(csTmp + bsNum)) {
             return csTmp + bsNum;
         }
@@ -343,7 +343,7 @@ CFX_ByteString CPDF_InterForm::GenerateNewResourceName(const CPDF_Dictionary* pR
 }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 typedef struct _PDF_FONTDATA {
-    FX_BOOL		bFind;
+    bool		bFind;
     LOGFONTA	lf;
 } PDF_FONTDATA, FAR* LPDF_FONTDATA;
 static int CALLBACK EnumFontFamExProc(	ENUMLOGFONTEXA *lpelfe,
@@ -357,10 +357,10 @@ static int CALLBACK EnumFontFamExProc(	ENUMLOGFONTEXA *lpelfe,
     }
     LPDF_FONTDATA pData = (LPDF_FONTDATA)lParam;
     memcpy(&pData->lf, &lpelfe->elfLogFont, sizeof(LOGFONTA));
-    pData->bFind = TRUE;
+    pData->bFind = true;
     return 0;
 }
-static FX_BOOL RetrieveSpecificFont(LOGFONTA& lf)
+static bool RetrieveSpecificFont(LOGFONTA& lf)
 {
     PDF_FONTDATA fd;
     memset(&fd, 0, sizeof(PDF_FONTDATA));
@@ -372,7 +372,7 @@ static FX_BOOL RetrieveSpecificFont(LOGFONTA& lf)
     }
     return fd.bFind;
 }
-static FX_BOOL RetrieveSpecificFont(uint8_t charSet, uint8_t pitchAndFamily, LPCSTR pcsFontName, LOGFONTA& lf)
+static bool RetrieveSpecificFont(uint8_t charSet, uint8_t pitchAndFamily, LPCSTR pcsFontName, LOGFONTA& lf)
 {
     memset(&lf, 0, sizeof(LOGFONTA));
     lf.lfCharSet = charSet;
@@ -382,7 +382,7 @@ static FX_BOOL RetrieveSpecificFont(uint8_t charSet, uint8_t pitchAndFamily, LPC
     }
     return RetrieveSpecificFont(lf);
 }
-static FX_BOOL RetrieveStockFont(int iFontObject, uint8_t charSet, LOGFONTA& lf)
+static bool RetrieveStockFont(int iFontObject, uint8_t charSet, LOGFONTA& lf)
 {
     HFONT hFont = (HFONT)::GetStockObject(iFontObject);
     if (hFont != NULL) {
@@ -392,7 +392,7 @@ static FX_BOOL RetrieveStockFont(int iFontObject, uint8_t charSet, LOGFONTA& lf)
             return RetrieveSpecificFont(lf);
         }
     }
-    return FALSE;
+    return false;
 }
 #endif
 CPDF_Font* CPDF_InterForm::AddSystemDefaultFont(const CPDF_Document* pDocument)
@@ -403,13 +403,13 @@ CPDF_Font* CPDF_InterForm::AddSystemDefaultFont(const CPDF_Document* pDocument)
     CPDF_Font* pFont = NULL;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     LOGFONTA lf;
-    FX_BOOL bRet;
+    bool bRet;
     bRet = RetrieveStockFont(DEFAULT_GUI_FONT, 255, lf);
     if (!bRet) {
         bRet = RetrieveStockFont(SYSTEM_FONT, 255, lf);
     }
     if (bRet) {
-        pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
+        pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, false, true);
     }
 #endif
     return pFont;
@@ -430,7 +430,7 @@ CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_Byt
         ::GetObjectA(hFont, sizeof(LOGFONTA), &lf);
         ::DeleteObject(hFont);
         if (strlen(lf.lfFaceName) > 0) {
-            return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
+            return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, false, true);
         }
     }
 #endif
@@ -452,7 +452,7 @@ CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_Wid
         ::GetObject(hFont, sizeof(LOGFONTA), &lf);
         ::DeleteObject(hFont);
         if (strlen(lf.lfFaceName) > 0) {
-            return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
+            return ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, false, true);
         }
     }
 #endif
@@ -477,12 +477,12 @@ CFX_ByteString CPDF_InterForm::GetNativeFont(uint8_t charSet, void* pLogFont)
     CFX_ByteString csFontName;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     LOGFONTA lf;
-    FX_BOOL bRet;
+    bool bRet;
     if (charSet == ANSI_CHARSET) {
         csFontName = "Helvetica";
         return csFontName;
     }
-    bRet = FALSE;
+    bRet = false;
     if (charSet == SHIFTJIS_CHARSET) {
         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MS Mincho", lf);
     } else if (charSet == GB2312_CHARSET) {
@@ -591,7 +591,7 @@ CPDF_Font* CPDF_InterForm::AddNativeFont(uint8_t charSet, const CPDF_Document* p
         if (csFontName == "Helvetica") {
             pFont = AddStandardFont(pDocument, csFontName);
         } else {
-            pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, FALSE, TRUE);
+            pFont = ((CPDF_Document*)pDocument)->AddWindowsFont(&lf, false, true);
         }
     }
 #endif
@@ -607,15 +607,15 @@ CPDF_Font* CPDF_InterForm::AddNativeFont(const CPDF_Document* pDocument)
     pFont = AddNativeFont(charSet, pDocument);
     return pFont;
 }
-FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType, const CPDF_FormField* pExcludedField, const CPDF_FormControl* pExcludedControl)
+bool CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType, const CPDF_FormField* pExcludedField, const CPDF_FormControl* pExcludedControl)
 {
     if (csNewFieldName.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     int iPos = 0;
     int iLength = csNewFieldName.GetLength();
     CFX_WideString csSub;
-    while (TRUE) {
+    while (true) {
         while (iPos < iLength && (csNewFieldName[iPos] == L'.' || csNewFieldName[iPos] == L' ')) {
             iPos ++;
         }
@@ -651,15 +651,15 @@ FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iT
             int iRet = CompareFieldName(csSub, csFullName);
             if (iRet == 1) {
                 if (pField->GetFieldType() != iType) {
-                    return FALSE;
+                    return false;
                 }
             } else if (iRet == 2 && csSub == csNewFieldName) {
                 if (csFullName[iPos] == L'.') {
-                    return FALSE;
+                    return false;
                 }
             } else if (iRet == 3 && csSub == csNewFieldName) {
                 if (csNewFieldName[csFullName.GetLength()] == L'.') {
-                    return FALSE;
+                    return false;
                 }
             }
         }
@@ -668,26 +668,26 @@ FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iT
         }
     }
     if (csSub.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     csNewFieldName = csSub;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType)
+bool CPDF_InterForm::ValidateFieldName(CFX_WideString& csNewFieldName, int iType)
 {
     return ValidateFieldName(csNewFieldName, iType, NULL, NULL);
 }
-FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField, CFX_WideString& csNewFieldName)
+bool CPDF_InterForm::ValidateFieldName(const CPDF_FormField* pField, CFX_WideString& csNewFieldName)
 {
     if (pField == NULL || csNewFieldName.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     return ValidateFieldName(csNewFieldName, ((CPDF_FormField*)pField)->GetFieldType(), pField, NULL);
 }
-FX_BOOL CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl, CFX_WideString& csNewFieldName)
+bool CPDF_InterForm::ValidateFieldName(const CPDF_FormControl* pControl, CFX_WideString& csNewFieldName)
 {
     if (pControl == NULL || csNewFieldName.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CPDF_FormField* pField = ((CPDF_FormControl*)pControl)->GetField();
     return ValidateFieldName(csNewFieldName, pField->GetFieldType(), pField, pControl);
@@ -764,19 +764,19 @@ void CPDF_InterForm::GetAllFieldNames(CFX_WideStringArray& allFieldNames)
         }
     }
 }
-FX_BOOL CPDF_InterForm::IsValidFormField(const void* pField)
+bool CPDF_InterForm::IsValidFormField(const void* pField)
 {
     if (pField == NULL) {
-        return FALSE;
+        return false;
     }
     int nCount = m_pFieldTree->m_Root.CountFields();
     for (int i = 0; i < nCount; i++) {
         CPDF_FormField *pFormField = m_pFieldTree->m_Root.GetField(i);
         if (pField == pFormField) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 CPDF_FormField* CPDF_InterForm::GetFieldByDict(CPDF_Dictionary* pFieldDict) const
 {
@@ -808,10 +808,10 @@ CPDF_FormControl* CPDF_InterForm::GetControl(FX_DWORD index, CFX_WideString csFi
     }
     return NULL;
 }
-FX_BOOL CPDF_InterForm::IsValidFormControl(const void* pControl)
+bool CPDF_InterForm::IsValidFormControl(const void* pControl)
 {
     if (pControl == NULL) {
-        return FALSE;
+        return false;
     }
     FX_POSITION pos = m_ControlMap.GetStartPosition();
     while (pos) {
@@ -819,10 +819,10 @@ FX_BOOL CPDF_InterForm::IsValidFormControl(const void* pControl)
         void* pFormControl = NULL;
         m_ControlMap.GetNextAssoc(pos, (void*&)pWidgetDict, pFormControl);
         if (pControl == pFormControl) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 int CPDF_InterForm::CountPageControls(CPDF_Page* pPage) const
 {
@@ -919,7 +919,7 @@ FX_DWORD CPDF_InterForm::CountInternalFields(const CFX_WideString& csFieldName)
             csSub += csFieldName[iPos ++];
         }
         int iCount = pArray->GetCount();
-        FX_BOOL bFind = FALSE;
+        bool bFind = false;
         for (int i = 0; i < iCount; i ++) {
             pDict = pArray->GetDict(i);
             if (pDict == NULL) {
@@ -927,7 +927,7 @@ FX_DWORD CPDF_InterForm::CountInternalFields(const CFX_WideString& csFieldName)
             }
             CFX_WideString csT = pDict->GetUnicodeText("T");
             if (csT == csSub) {
-                bFind = TRUE;
+                bFind = true;
                 break;
             }
         }
@@ -970,7 +970,7 @@ CPDF_Dictionary* CPDF_InterForm::GetInternalField(FX_DWORD index, const CFX_Wide
             csSub += csFieldName[iPos ++];
         }
         int iCount = pArray->GetCount();
-        FX_BOOL bFind = FALSE;
+        bool bFind = false;
         for (int i = 0; i < iCount; i ++) {
             pDict = pArray->GetDict(i);
             if (pDict == NULL) {
@@ -978,7 +978,7 @@ CPDF_Dictionary* CPDF_InterForm::GetInternalField(FX_DWORD index, const CFX_Wide
             }
             CFX_WideString csT = pDict->GetUnicodeText("T");
             if (csT == csSub) {
-                bFind = TRUE;
+                bFind = true;
                 break;
             }
         }
@@ -996,14 +996,14 @@ CPDF_Dictionary* CPDF_InterForm::GetInternalField(FX_DWORD index, const CFX_Wide
     pArray = pDict->GetArray("Kids");
     return pArray ? pArray->GetDict(index) : pDict;
 }
-FX_BOOL CPDF_InterForm::NeedConstructAP()
+bool CPDF_InterForm::NeedConstructAP()
 {
     if (m_pFormDict == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pFormDict->GetBoolean("NeedAppearances");
 }
-void CPDF_InterForm::NeedConstructAP(FX_BOOL bNeedAP)
+void CPDF_InterForm::NeedConstructAP(bool bNeedAP)
 {
     if (m_pFormDict == NULL) {
         InitInterFormDict(m_pFormDict, m_pDocument);
@@ -1078,37 +1078,37 @@ CPDF_Font* CPDF_InterForm::GetNativeFormFont(CFX_ByteString& csNameTag)
 {
     return GetNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
 }
-FX_BOOL CPDF_InterForm::FindFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag)
+bool CPDF_InterForm::FindFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag)
 {
     return FindInterFormFont(m_pFormDict, pFont, csNameTag);
 }
-FX_BOOL CPDF_InterForm::FindFormFont(CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag)
+bool CPDF_InterForm::FindFormFont(CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag)
 {
     return FindInterFormFont(m_pFormDict, m_pDocument, csFontName, pFont, csNameTag);
 }
 void CPDF_InterForm::AddFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag)
 {
     AddInterFormFont(m_pFormDict, m_pDocument, pFont, csNameTag);
-    m_bUpdated = TRUE;
+    m_bUpdated = true;
 }
 CPDF_Font* CPDF_InterForm::AddNativeFormFont(uint8_t charSet, CFX_ByteString& csNameTag)
 {
-    m_bUpdated = TRUE;
+    m_bUpdated = true;
     return AddNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
 }
 CPDF_Font* CPDF_InterForm::AddNativeFormFont(CFX_ByteString& csNameTag)
 {
-    m_bUpdated = TRUE;
+    m_bUpdated = true;
     return AddNativeInterFormFont(m_pFormDict, m_pDocument, csNameTag);
 }
 void CPDF_InterForm::RemoveFormFont(const CPDF_Font* pFont)
 {
-    m_bUpdated = TRUE;
+    m_bUpdated = true;
     RemoveInterFormFont(m_pFormDict, pFont);
 }
 void CPDF_InterForm::RemoveFormFont(CFX_ByteString csNameTag)
 {
-    m_bUpdated = TRUE;
+    m_bUpdated = true;
     RemoveInterFormFont(m_pFormDict, csNameTag);
 }
 CPDF_DefaultAppearance CPDF_InterForm::GetDefaultAppearance()
@@ -1131,12 +1131,12 @@ int CPDF_InterForm::GetFormAlignment()
     }
     return m_pFormDict->GetInteger("Q", 0);
 }
-FX_BOOL CPDF_InterForm::ResetForm(const CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude, FX_BOOL bNotify)
+bool CPDF_InterForm::ResetForm(const CFX_PtrArray& fields, bool bIncludeOrExclude, bool bNotify)
 {
     if (bNotify && m_pFormNotify != NULL) {
         int iRet = m_pFormNotify->BeforeFormReset(this);
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     int nCount = m_pFieldTree->m_Root.CountFields();
@@ -1145,11 +1145,11 @@ FX_BOOL CPDF_InterForm::ResetForm(const CFX_PtrArray& fields, FX_BOOL bIncludeOr
         if (pField == NULL) {
             continue;
         }
-        FX_BOOL bFind = FALSE;
+        bool bFind = false;
         int iCount = fields.GetSize();
         for (int i = 0; i < iCount; i ++) {
             if (pField == (CPDF_FormField*)fields[i]) {
-                bFind = TRUE;
+                bFind = true;
                 break;
             }
         }
@@ -1160,14 +1160,14 @@ FX_BOOL CPDF_InterForm::ResetForm(const CFX_PtrArray& fields, FX_BOOL bIncludeOr
     if (bNotify && m_pFormNotify != NULL) {
         m_pFormNotify->AfterFormReset(this);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_InterForm::ResetForm(FX_BOOL bNotify)
+bool CPDF_InterForm::ResetForm(bool bNotify)
 {
     if (bNotify && m_pFormNotify != NULL) {
         int iRet = m_pFormNotify->BeforeFormReset(this);
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     int nCount = m_pFieldTree->m_Root.CountFields();
@@ -1181,7 +1181,7 @@ FX_BOOL CPDF_InterForm::ResetForm(FX_BOOL bNotify)
     if (bNotify && m_pFormNotify != NULL) {
         m_pFormNotify->AfterFormReset(this);
     }
-    return TRUE;
+    return true;
 }
 void CPDF_InterForm::ReloadForm()
 {
@@ -1242,7 +1242,7 @@ void CPDF_InterForm::LoadField(CPDF_Dictionary* pFieldDict, int nLevel)
         AddTerminalField(pFieldDict);
     }
 }
-FX_BOOL CPDF_InterForm::HasXFAForm() const
+bool CPDF_InterForm::HasXFAForm() const
 {
     return m_pFormDict && m_pFormDict->GetArray(FX_BSTRC("XFA")) != NULL;
 }
@@ -1303,7 +1303,7 @@ CPDF_FormField* CPDF_InterForm::AddTerminalField(const CPDF_Dictionary* pFieldDi
         pField = new CPDF_FormField(this, pParent);
         CPDF_Object* pTObj = pDict->GetElement("T");
         if (pTObj && pTObj->GetType() == PDFOBJ_REFERENCE) {
-            CPDF_Object* pClone = pTObj->Clone(TRUE);
+            CPDF_Object* pClone = pTObj->Clone(true);
             if (pClone) {
                 pDict->SetAt("T", pClone);
             } else {
@@ -1342,7 +1342,7 @@ CPDF_FormControl* CPDF_InterForm::AddControl(const CPDF_FormField* pField, const
     ((CPDF_FormField*)pField)->m_ControlList.Add(pControl);
     return pControl;
 }
-CPDF_FormField* CPDF_InterForm::CheckRequiredFields(const CFX_PtrArray *fields, FX_BOOL bIncludeOrExclude) const
+CPDF_FormField* CPDF_InterForm::CheckRequiredFields(const CFX_PtrArray *fields, bool bIncludeOrExclude) const
 {
     int nCount = m_pFieldTree->m_Root.CountFields();
     for (int i = 0; i < nCount; i++) {
@@ -1358,7 +1358,7 @@ CPDF_FormField* CPDF_InterForm::CheckRequiredFields(const CFX_PtrArray *fields,
         if (dwFlags & 0x04) {
             continue;
         }
-        FX_BOOL bFind = TRUE;
+        bool bFind = true;
         if (fields != NULL) {
             bFind = fields->Find(pField, 0) >= 0;
         }
@@ -1371,7 +1371,7 @@ CPDF_FormField* CPDF_InterForm::CheckRequiredFields(const CFX_PtrArray *fields,
     }
     return NULL;
 }
-CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, FX_BOOL bSimpleFileSpec) const
+CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, bool bSimpleFileSpec) const
 {
     CFX_PtrArray fields;
     int nCount = m_pFieldTree->m_Root.CountFields();
@@ -1379,10 +1379,10 @@ CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, FX_B
         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
         fields.Add(pField);
     }
-    return ExportToFDF(pdf_path, fields, TRUE, bSimpleFileSpec);
+    return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
 }
 CFX_WideString FILESPEC_EncodeFileName(const CFX_WideStringC& filepath);
-CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude, FX_BOOL bSimpleFileSpec) const
+CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, CFX_PtrArray& fields, bool bIncludeOrExclude, bool bSimpleFileSpec) const
 {
     CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
     if (pDoc == NULL) {
@@ -1415,7 +1415,7 @@ CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, CFX_
         if (dwFlags & 0x04) {
             continue;
         }
-        FX_BOOL bFind = fields.Find(pField, 0) >= 0;
+        bool bFind = fields.Find(pField, 0) >= 0;
         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
             if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetString("V").IsEmpty()) {
                 continue;
@@ -1432,7 +1432,7 @@ CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, CFX_
             }
             pFieldDict->SetAt("T", pString);
             if (pField->GetType() == CPDF_FormField::CheckBox || pField->GetType() == CPDF_FormField::RadioButton) {
-                CFX_WideString csExport = pField->GetCheckValue(FALSE);
+                CFX_WideString csExport = pField->GetCheckValue(false);
                 CFX_ByteString csBExport = PDF_EncodeText(csExport);
                 CPDF_Object* pOpt = FPDF_GetFieldAttr(pField->m_pDict, "Opt");
                 if (pOpt == NULL) {
@@ -1443,7 +1443,7 @@ CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path, CFX_
             } else {
                 CPDF_Object* pV = FPDF_GetFieldAttr(pField->m_pDict, "V");
                 if (pV != NULL) {
-                    pFieldDict->SetAt("V", pV->Clone(TRUE));
+                    pFieldDict->SetAt("V", pV->Clone(true));
                 }
             }
             pFields->Add(pFieldDict);
@@ -1483,7 +1483,7 @@ static void FPDFDOC_FDF_GetFieldValue(CPDF_Dictionary *pFieldDict, CFX_WideStrin
         csValue = CFX_WideString::FromLocal(csBValue);
     }
 }
-void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict, const CFX_WideString& parent_name, FX_BOOL bNotify, int nLevel)
+void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict, const CFX_WideString& parent_name, bool bNotify, int nLevel)
 {
     CFX_WideString name;
     if (!parent_name.IsEmpty()) {
@@ -1531,7 +1531,7 @@ void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict, const CFX_Wide
     pField->SetValue(csWValue);
     CPDF_FormField::Type eType = pField->GetType();
     if ((eType == CPDF_FormField::ListBox || eType == CPDF_FormField::ComboBox) && pFieldDict->KeyExist("Opt")) {
-        pField->m_pDict->SetAt("Opt", pFieldDict->GetElementValue("Opt")->Clone(TRUE));
+        pField->m_pDict->SetAt("Opt", pFieldDict->GetElementValue("Opt")->Clone(true));
     }
     if (bNotify && m_pFormNotify != NULL) {
         if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON) {
@@ -1546,24 +1546,24 @@ void CPDF_InterForm::FDF_ImportField(CPDF_Dictionary* pFieldDict, const CFX_Wide
         pField->UpdateAP(NULL);
     }
 }
-FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF, FX_BOOL bNotify)
+bool CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF, bool bNotify)
 {
     if (pFDF == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pMainDict = pFDF->GetRoot()->GetDict("FDF");
     if (pMainDict == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pFields = pMainDict->GetArray("Fields");
     if (pFields == NULL) {
-        return FALSE;
+        return false;
     }
     m_bsEncoding = pMainDict->GetString(FX_BSTRC("Encoding"));
     if (bNotify && m_pFormNotify != NULL) {
         int iRet = m_pFormNotify->BeforeFormImportData(this);
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     for (FX_DWORD i = 0; i < pFields->GetCount(); i ++) {
@@ -1576,13 +1576,13 @@ FX_BOOL CPDF_InterForm::ImportFromFDF(const CFDF_Document* pFDF, FX_BOOL bNotify
     if (bNotify && m_pFormNotify != NULL) {
         m_pFormNotify->AfterFormImportData(this);
     }
-    return TRUE;
+    return true;
 }
 void CPDF_InterForm::SetFormNotify(const CPDF_FormNotify* pNotify)
 {
     m_pFormNotify = (CPDF_FormNotify*)pNotify;
 }
-int CPDF_InterForm::GetPageWithWidget(int iCurPage, FX_BOOL bNext)
+int CPDF_InterForm::GetPageWithWidget(int iCurPage, bool bNext)
 {
     if (iCurPage < 0) {
         return -1;
@@ -1622,6 +1622,6 @@ int CPDF_InterForm::GetPageWithWidget(int iCurPage, FX_BOOL bNext)
                 return iNewPage;
             }
         }
-    } while (TRUE);
+    } while (true);
     return -1;
 }
diff --git a/core/src/fpdfdoc/doc_formcontrol.cpp b/core/src/fpdfdoc/doc_formcontrol.cpp
index 87eee92c2e..62eb591f94 100644
--- a/core/src/fpdfdoc/doc_formcontrol.cpp
+++ b/core/src/fpdfdoc/doc_formcontrol.cpp
@@ -113,25 +113,25 @@ CFX_WideString CPDF_FormControl::GetExportValue()
     CFX_WideString csWOn = PDF_DecodeText(csOn);
     return csWOn;
 }
-FX_BOOL CPDF_FormControl::IsChecked()
+bool CPDF_FormControl::IsChecked()
 {
     ASSERT(GetType() == CPDF_FormField::CheckBox || GetType() == CPDF_FormField::RadioButton);
     CFX_ByteString csOn = GetOnStateName();
     CFX_ByteString csAS = m_pWidgetDict->GetString("AS");
     return csAS == csOn;
 }
-FX_BOOL CPDF_FormControl::IsDefaultChecked()
+bool CPDF_FormControl::IsDefaultChecked()
 {
     ASSERT(GetType() == CPDF_FormField::CheckBox || GetType() == CPDF_FormField::RadioButton);
     CPDF_Object* pDV = FPDF_GetFieldAttr(m_pField->m_pDict, "DV");
     if (pDV == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString csDV = pDV->GetString();
     CFX_ByteString csOn = GetOnStateName();
     return (csDV == csOn);
 }
-void CPDF_FormControl::CheckControl(FX_BOOL bChecked)
+void CPDF_FormControl::CheckControl(bool bChecked)
 {
     ASSERT(GetType() == CPDF_FormField::CheckBox || GetType() == CPDF_FormField::RadioButton);
     CFX_ByteString csOn = GetOnStateName();
@@ -144,7 +144,7 @@ void CPDF_FormControl::CheckControl(FX_BOOL bChecked)
         return;
     }
     m_pWidgetDict->SetAtName("AS", csAS);
-    m_pForm->m_bUpdated = TRUE;
+    m_pForm->m_bUpdated = true;
 }
 CPDF_Stream* FPDFDOC_GetAnnotAP(CPDF_Dictionary* pAnnotDict, CPDF_Annot::AppearanceMode mode);
 void CPDF_FormControl::DrawControl(CFX_RenderDevice* pDevice, CFX_AffineMatrix* pMatrix, CPDF_Page* pPage,
@@ -186,7 +186,7 @@ CPDF_FormControl::HighlightingMode CPDF_FormControl::GetHighlightingMode()
     }
     return Invert;
 }
-CPDF_ApSettings CPDF_FormControl::GetMK(FX_BOOL bCreate)
+CPDF_ApSettings CPDF_FormControl::GetMK(bool bCreate)
 {
     if (!m_pWidgetDict) {
         return NULL;
@@ -201,49 +201,49 @@ CPDF_ApSettings CPDF_FormControl::GetMK(FX_BOOL bCreate)
     }
     return mk;
 }
-FX_BOOL CPDF_FormControl::HasMKEntry(CFX_ByteString csEntry)
+bool CPDF_FormControl::HasMKEntry(CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.HasMKEntry(csEntry);
 }
 int CPDF_FormControl::GetRotation()
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetRotation();
 }
 FX_ARGB CPDF_FormControl::GetColor(int& iColorType, CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetColor(iColorType, csEntry);
 }
 FX_FLOAT CPDF_FormControl::GetOriginalColor(int index, CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetOriginalColor(index, csEntry);
 }
 void CPDF_FormControl::GetOriginalColor(int& iColorType, FX_FLOAT fc[4], CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     mk.GetOriginalColor(iColorType, fc, csEntry);
 }
 CFX_WideString CPDF_FormControl::GetCaption(CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetCaption(csEntry);
 }
 CPDF_Stream* CPDF_FormControl::GetIcon(CFX_ByteString csEntry)
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetIcon(csEntry);
 }
 CPDF_IconFit CPDF_FormControl::GetIconFit()
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetIconFit();
 }
 int CPDF_FormControl::GetTextPosition()
 {
-    CPDF_ApSettings mk = GetMK(FALSE);
+    CPDF_ApSettings mk = GetMK(false);
     return mk.GetTextPosition();
 }
 CPDF_Action CPDF_FormControl::GetAction()
@@ -343,10 +343,10 @@ int CPDF_FormControl::GetControlAlignment()
     }
     return pObj->GetInteger();
 }
-FX_BOOL CPDF_ApSettings::HasMKEntry(const CFX_ByteStringC& csEntry)
+bool CPDF_ApSettings::HasMKEntry(const CFX_ByteStringC& csEntry)
 {
     if (m_pDict == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pDict->KeyExist(csEntry);
 }
diff --git a/core/src/fpdfdoc/doc_formfield.cpp b/core/src/fpdfdoc/doc_formfield.cpp
index 087eba8aa4..8d9887e796 100644
--- a/core/src/fpdfdoc/doc_formfield.cpp
+++ b/core/src/fpdfdoc/doc_formfield.cpp
@@ -7,11 +7,11 @@
 #include "../../include/fpdfdoc/fpdf_doc.h"
 #include "doc_utils.h"
 
-FX_BOOL PDF_FormField_IsUnison(CPDF_FormField *pField)
+bool PDF_FormField_IsUnison(CPDF_FormField *pField)
 {
-    FX_BOOL bUnison = FALSE;
+    bool bUnison = false;
     if (pField->GetType() == CPDF_FormField::CheckBox) {
-        bUnison = TRUE;
+        bUnison = true;
     } else {
         FX_DWORD dwFlags = pField->GetFieldFlags();
         bUnison = ((dwFlags & 0x2000000) != 0);
@@ -100,7 +100,7 @@ CFX_WideString CPDF_FormField::GetFullName()
 {
     return ::GetFullName(m_pDict);
 }
-FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
+bool CPDF_FormField::ResetField(bool bNotify)
 {
     switch (m_Type) {
         case CPDF_FormField::CheckBox:
@@ -113,13 +113,13 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 if (iCount) {
                     if (PDF_FormField_IsUnison(this)) {
                         for(int i = 0; i < iCount; i++) {
-                            CheckControl(i, GetControl(i)->IsDefaultChecked(), FALSE);
+                            CheckControl(i, GetControl(i)->IsDefaultChecked(), false);
                         }
                     } else {
                         for (int i = 0; i < iCount; i ++) {
                             CPDF_FormControl* pControl = GetControl(i);
-                            FX_BOOL bChecked = pControl->IsDefaultChecked();
-                            CheckControl(i, bChecked, FALSE);
+                            bool bChecked = pControl->IsDefaultChecked();
+                            CheckControl(i, bChecked, false);
                         }
                     }
                 }
@@ -138,10 +138,10 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     int iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
                     if (iRet < 0) {
-                        return FALSE;
+                        return false;
                     }
                 }
-                SetItemSelection(iIndex, TRUE);
+                SetItemSelection(iIndex, true);
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     m_pForm->m_pFormNotify->AfterValueChange(this);
                 }
@@ -157,10 +157,10 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     int iRet = m_pForm->m_pFormNotify->BeforeSelectionChange(this, csValue);
                     if (iRet < 0) {
-                        return FALSE;
+                        return false;
                     }
                 }
-                SetItemSelection(iIndex, TRUE);
+                SetItemSelection(iIndex, true);
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     m_pForm->m_pFormNotify->AfterSelectionChange(this);
                 }
@@ -182,12 +182,12 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 }
                 CPDF_Object* pRV = FPDF_GetFieldAttr(m_pDict, "RV");
                 if (!pRV && (csDValue == csValue)) {
-                    return FALSE;
+                    return false;
                 }
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     int iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csDValue);
                     if (iRet < 0) {
-                        return FALSE;
+                        return false;
                     }
                 }
                 if (pDV == NULL) {
@@ -196,7 +196,7 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 } else {
                     CPDF_Object* pClone = pDV->Clone();
                     if (pClone == NULL) {
-                        return FALSE;
+                        return false;
                     }
                     m_pDict->SetAt("V", pClone);
                     if(pRV) {
@@ -207,11 +207,11 @@ FX_BOOL CPDF_FormField::ResetField(FX_BOOL bNotify)
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     m_pForm->m_pFormNotify->AfterValueChange(this);
                 }
-                m_pForm->m_bUpdated = TRUE;
+                m_pForm->m_bUpdated = true;
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 int CPDF_FormField::GetControlIndex(const CPDF_FormControl* pControl)
 {
@@ -299,7 +299,7 @@ CFX_WideString CPDF_FormField::GetRichTextString()
     }
     return pObj->GetUnicodeText();
 }
-CFX_WideString CPDF_FormField::GetValue(FX_BOOL bDefault)
+CFX_WideString CPDF_FormField::GetValue(bool bDefault)
 {
     if (GetType() == CheckBox || GetType() == RadioButton) {
         return GetCheckValue(bDefault);
@@ -333,19 +333,19 @@ CFX_WideString CPDF_FormField::GetValue(FX_BOOL bDefault)
 }
 CFX_WideString CPDF_FormField::GetValue()
 {
-    return GetValue(FALSE);
+    return GetValue(false);
 }
 CFX_WideString CPDF_FormField::GetDefaultValue()
 {
-    return GetValue(TRUE);
+    return GetValue(true);
 }
-FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bDefault, FX_BOOL bNotify)
+bool CPDF_FormField::SetValue(const CFX_WideString& value, bool bDefault, bool bNotify)
 {
     switch (m_Type) {
         case CheckBox:
         case RadioButton: {
                 SetCheckValue(value, bDefault, bNotify);
-                return TRUE;
+                return true;
             }
         case File:
         case RichText:
@@ -355,7 +355,7 @@ FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bDefault,
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     int iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
                     if (iRet < 0) {
-                        return FALSE;
+                        return false;
                     }
                 }
                 int iIndex = FindOptionValue(csValue);
@@ -371,39 +371,39 @@ FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bDefault,
                     if (bDefault) {
                     } else {
                         ClearSelection();
-                        SetItemSelection(iIndex, TRUE);
+                        SetItemSelection(iIndex, true);
                     }
                 }
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     m_pForm->m_pFormNotify->AfterValueChange(this);
                 }
-                m_pForm->m_bUpdated = TRUE;
+                m_pForm->m_bUpdated = true;
             }
             break;
         case ListBox: {
                 int iIndex = FindOptionValue(value);
                 if (iIndex < 0) {
-                    return FALSE;
+                    return false;
                 }
                 if (bDefault && iIndex == GetDefaultSelectedItem()) {
-                    return FALSE;
+                    return false;
                 }
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     CFX_WideString csValue = value;
                     int iRet = m_pForm->m_pFormNotify->BeforeSelectionChange(this, csValue);
                     if (iRet < 0) {
-                        return FALSE;
+                        return false;
                     }
                 }
                 if (bDefault) {
                 } else {
                     ClearSelection();
-                    SetItemSelection(iIndex, TRUE);
+                    SetItemSelection(iIndex, true);
                 }
                 if (bNotify && m_pForm->m_pFormNotify != NULL) {
                     m_pForm->m_pFormNotify->AfterSelectionChange(this);
                 }
-                m_pForm->m_bUpdated = TRUE;
+                m_pForm->m_bUpdated = true;
                 break;
             }
         default:
@@ -412,11 +412,11 @@ FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bDefault,
     if (CPDF_InterForm::m_bUpdateAP) {
         UpdateAP(NULL);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_FormField::SetValue(const CFX_WideString& value, FX_BOOL bNotify)
+bool CPDF_FormField::SetValue(const CFX_WideString& value, bool bNotify)
 {
-    return SetValue(value, FALSE, bNotify);
+    return SetValue(value, false, bNotify);
 }
 int CPDF_FormField::GetMaxLen()
 {
@@ -506,7 +506,7 @@ int CPDF_FormField::GetSelectedIndex(int index)
     }
     return -1;
 }
-FX_BOOL CPDF_FormField::ClearSelection(FX_BOOL bNotify)
+bool CPDF_FormField::ClearSelection(bool bNotify)
 {
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
         int iRet = 0;
@@ -522,7 +522,7 @@ FX_BOOL CPDF_FormField::ClearSelection(FX_BOOL bNotify)
             iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
         }
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     m_pDict->RemoveAt("V");
@@ -538,43 +538,43 @@ FX_BOOL CPDF_FormField::ClearSelection(FX_BOOL bNotify)
     if (CPDF_InterForm::m_bUpdateAP) {
         UpdateAP(NULL);
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
-FX_BOOL CPDF_FormField::IsItemSelected(int index)
+bool CPDF_FormField::IsItemSelected(int index)
 {
     ASSERT(GetType() == ComboBox || GetType() == ListBox);
     if (index < 0 || index >= CountOptions()) {
-        return FALSE;
+        return false;
     }
     if (IsOptionSelected(index)) {
-        return TRUE;
+        return true;
     }
     CFX_WideString opt_value = GetOptionValue(index);
     CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
     if (pValue == NULL) {
         pValue = FPDF_GetFieldAttr(m_pDict, "I");
         if (pValue == NULL) {
-            return FALSE;
+            return false;
         }
     }
     if (pValue->GetType() == PDFOBJ_STRING) {
         if (pValue->GetUnicodeText() == opt_value) {
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (pValue->GetType() == PDFOBJ_NUMBER) {
         if (pValue->GetString().IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (pValue->GetInteger() == index) {
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (pValue->GetType() != PDFOBJ_ARRAY) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray = (CPDF_Array*)pValue;
     int iPos = -1;
@@ -586,15 +586,15 @@ FX_BOOL CPDF_FormField::IsItemSelected(int index)
     }
     for (FX_DWORD i = 0; i < pArray->GetCount(); i ++)
         if (pArray->GetElementValue(i)->GetUnicodeText() == opt_value && (int)i == iPos) {
-            return TRUE;
+            return true;
         }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL bNotify)
+bool CPDF_FormField::SetItemSelection(int index, bool bSelected, bool bNotify)
 {
     ASSERT(GetType() == ComboBox || GetType() == ListBox);
     if (index < 0 || index >= CountOptions()) {
-        return FALSE;
+        return false;
     }
     CFX_WideString opt_value = GetOptionValue(index);
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
@@ -606,14 +606,14 @@ FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL b
             iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, opt_value);
         }
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     if (!bSelected) {
         CPDF_Object* pValue = FPDF_GetFieldAttr(m_pDict, "V");
         if (pValue != NULL) {
             if (m_Type == ListBox) {
-                SelectOption(index, FALSE);
+                SelectOption(index, false);
                 if (pValue->GetType() == PDFOBJ_STRING) {
                     if (pValue->GetUnicodeText() == opt_value) {
                         m_pDict->RemoveAt("V");
@@ -621,7 +621,7 @@ FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL b
                 } else if (pValue->GetType() == PDFOBJ_ARRAY) {
                     CPDF_Array* pArray = CPDF_Array::Create();
                     if (pArray == NULL) {
-                        return FALSE;
+                        return false;
                     }
                     int iCount = CountOptions();
                     for (int i = 0; i < iCount; i ++) {
@@ -645,21 +645,21 @@ FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL b
         }
     } else {
         if (m_Type == ListBox) {
-            SelectOption(index, TRUE);
+            SelectOption(index, true);
             if (!(m_Flags & FORMLIST_MULTISELECT)) {
                 m_pDict->SetAtString("V", PDF_EncodeText(opt_value));
             } else {
                 CPDF_Array* pArray = CPDF_Array::Create();
                 if (pArray == NULL) {
-                    return FALSE;
+                    return false;
                 }
-                FX_BOOL bSelected;
+                bool bSelected;
                 int iCount = CountOptions();
                 for (int i = 0; i < iCount; i ++) {
                     if (i != index) {
                         bSelected = IsItemSelected(i);
                     } else {
-                        bSelected = TRUE;
+                        bSelected = true;
                     }
                     if (bSelected) {
                         opt_value = GetOptionValue(i);
@@ -672,7 +672,7 @@ FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL b
             m_pDict->SetAtString("V", PDF_EncodeText(opt_value));
             CPDF_Array* pI = CPDF_Array::Create();
             if (pI == NULL) {
-                return FALSE;
+                return false;
             }
             pI->AddInteger(index);
             m_pDict->SetAt("I", pI);
@@ -689,18 +689,18 @@ FX_BOOL CPDF_FormField::SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL b
     if (CPDF_InterForm::m_bUpdateAP) {
         UpdateAP(NULL);
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
-FX_BOOL CPDF_FormField::IsItemDefaultSelected(int index)
+bool CPDF_FormField::IsItemDefaultSelected(int index)
 {
     ASSERT(GetType() == ComboBox || GetType() == ListBox);
     if (index < 0 || index >= CountOptions()) {
-        return FALSE;
+        return false;
     }
     int iDVIndex = GetDefaultSelectedItem();
     if (iDVIndex < 0) {
-        return FALSE;
+        return false;
     }
     return (iDVIndex == index);
 }
@@ -798,15 +798,15 @@ int CPDF_FormField::FindOptionValue(const CFX_WideString& csOptValue, int iStart
     }
     return -1;
 }
-FX_BOOL CPDF_FormField::CheckControl(int iControlIndex, FX_BOOL bChecked, FX_BOOL bNotify)
+bool CPDF_FormField::CheckControl(int iControlIndex, bool bChecked, bool bNotify)
 {
     ASSERT(GetType() == CheckBox || GetType() == RadioButton);
     CPDF_FormControl* pControl = GetControl(iControlIndex);
     if (pControl == NULL) {
-        return FALSE;
+        return false;
     }
     if (!bChecked && pControl->IsChecked() == bChecked) {
-        return FALSE;
+        return false;
     }
     CFX_ByteArray statusArray;
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
@@ -815,7 +815,7 @@ FX_BOOL CPDF_FormField::CheckControl(int iControlIndex, FX_BOOL bChecked, FX_BOO
     CFX_WideString csWExport = pControl->GetExportValue();
     CFX_ByteString csBExport = PDF_EncodeText(csWExport);
     int iCount = CountControls();
-    FX_BOOL bUnison = PDF_FormField_IsUnison(this);
+    bool bUnison = PDF_FormField_IsUnison(this);
     for (int i = 0; i < iCount; i ++) {
         CPDF_FormControl* pCtrl = GetControl(i);
         if (bUnison) {
@@ -824,16 +824,16 @@ FX_BOOL CPDF_FormField::CheckControl(int iControlIndex, FX_BOOL bChecked, FX_BOO
                 if (pCtrl->GetOnStateName() == pControl->GetOnStateName()) {
                     pCtrl->CheckControl(bChecked);
                 } else if (bChecked) {
-                    pCtrl->CheckControl(FALSE);
+                    pCtrl->CheckControl(false);
                 }
             } else if (bChecked) {
-                pCtrl->CheckControl(FALSE);
+                pCtrl->CheckControl(false);
             }
         } else {
             if (i == iControlIndex) {
                 pCtrl->CheckControl(bChecked);
             } else if (bChecked) {
-                pCtrl->CheckControl(FALSE);
+                pCtrl->CheckControl(false);
             }
         }
     }
@@ -859,14 +859,14 @@ FX_BOOL CPDF_FormField::CheckControl(int iControlIndex, FX_BOOL bChecked, FX_BOO
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
         m_pForm->m_pFormNotify->AfterCheckedStatusChange(this, statusArray);
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
-CFX_WideString CPDF_FormField::GetCheckValue(FX_BOOL bDefault)
+CFX_WideString CPDF_FormField::GetCheckValue(bool bDefault)
 {
     ASSERT(GetType() == CheckBox || GetType() == RadioButton);
     CFX_WideString csExport = L"Off";
-    FX_BOOL bChecked;
+    bool bChecked;
     int iCount = CountControls();
     for (int i = 0; i < iCount; i ++) {
         CPDF_FormControl* pControl = GetControl(i);
@@ -882,7 +882,7 @@ CFX_WideString CPDF_FormField::GetCheckValue(FX_BOOL bDefault)
     }
     return csExport;
 }
-FX_BOOL CPDF_FormField::SetCheckValue(const CFX_WideString& value, FX_BOOL bDefault, FX_BOOL bNotify)
+bool CPDF_FormField::SetCheckValue(const CFX_WideString& value, bool bDefault, bool bNotify)
 {
     ASSERT(GetType() == CheckBox || GetType() == RadioButton);
     CFX_ByteArray statusArray;
@@ -896,21 +896,21 @@ FX_BOOL CPDF_FormField::SetCheckValue(const CFX_WideString& value, FX_BOOL bDefa
         if (csExport == value) {
             if (bDefault) {
             } else {
-                CheckControl(GetControlIndex(pControl), TRUE);
+                CheckControl(GetControlIndex(pControl), true);
             }
             break;
         } else {
             if (bDefault) {
             } else {
-                CheckControl(GetControlIndex(pControl), FALSE);
+                CheckControl(GetControlIndex(pControl), false);
             }
         }
     }
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
         m_pForm->m_pFormNotify->AfterCheckedStatusChange(this, statusArray);
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
 int CPDF_FormField::GetTopVisibleIndex()
 {
@@ -948,43 +948,43 @@ int CPDF_FormField::GetSelectedOptionIndex(int index)
     }
     return -1;
 }
-FX_BOOL CPDF_FormField::IsOptionSelected(int iOptIndex)
+bool CPDF_FormField::IsOptionSelected(int iOptIndex)
 {
     CPDF_Object* pObj = FPDF_GetFieldAttr(m_pDict, "I");
     if (pObj == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray = pObj->GetArray();
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     int iCount = (int)pArray->GetCount();
     for (int i = 0; i < iCount; i ++) {
         if (pArray->GetInteger(i) == iOptIndex) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_FormField::SelectOption(int iOptIndex, FX_BOOL bSelected, FX_BOOL bNotify)
+bool CPDF_FormField::SelectOption(int iOptIndex, bool bSelected, bool bNotify)
 {
     CPDF_Array* pArray = m_pDict->GetArray("I");
     if (pArray == NULL) {
         if (!bSelected) {
-            return TRUE;
+            return true;
         }
         pArray = CPDF_Array::Create();
         if (pArray == NULL) {
-            return FALSE;
+            return false;
         }
         m_pDict->SetAt("I", pArray);
     }
-    FX_BOOL bReturn = FALSE;
+    bool bReturn = false;
     for (int i = 0; i < (int)pArray->GetCount(); i ++) {
         int iFind = pArray->GetInteger(i);
         if (iFind == iOptIndex) {
             if (bSelected) {
-                return TRUE;
+                return true;
             }
             if (bNotify && m_pForm->m_pFormNotify != NULL) {
                 int iRet = 0;
@@ -996,11 +996,11 @@ FX_BOOL CPDF_FormField::SelectOption(int iOptIndex, FX_BOOL bSelected, FX_BOOL b
                     iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
                 }
                 if (iRet < 0) {
-                    return FALSE;
+                    return false;
                 }
             }
             pArray->RemoveAt(i);
-            bReturn = TRUE;
+            bReturn = true;
             break;
         } else if (iFind > iOptIndex) {
             if (!bSelected) {
@@ -1016,15 +1016,15 @@ FX_BOOL CPDF_FormField::SelectOption(int iOptIndex, FX_BOOL bSelected, FX_BOOL b
                     iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
                 }
                 if (iRet < 0) {
-                    return FALSE;
+                    return false;
                 }
             }
             CPDF_Number* pNum = CPDF_Number::Create(iOptIndex);
             if (pNum == NULL) {
-                return FALSE;
+                return false;
             }
             pArray->InsertAt(i, pNum);
-            bReturn = TRUE;
+            bReturn = true;
             break;
         }
     }
@@ -1044,10 +1044,10 @@ FX_BOOL CPDF_FormField::SelectOption(int iOptIndex, FX_BOOL bSelected, FX_BOOL b
             m_pForm->m_pFormNotify->AfterValueChange(this);
         }
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
-FX_BOOL CPDF_FormField::ClearSelectedOptions(FX_BOOL bNotify)
+bool CPDF_FormField::ClearSelectedOptions(bool bNotify)
 {
     if (bNotify && m_pForm->m_pFormNotify != NULL) {
         int iRet = 0;
@@ -1063,7 +1063,7 @@ FX_BOOL CPDF_FormField::ClearSelectedOptions(FX_BOOL bNotify)
             iRet = m_pForm->m_pFormNotify->BeforeValueChange(this, csValue);
         }
         if (iRet < 0) {
-            return FALSE;
+            return false;
         }
     }
     m_pDict->RemoveAt("I");
@@ -1075,8 +1075,8 @@ FX_BOOL CPDF_FormField::ClearSelectedOptions(FX_BOOL bNotify)
             m_pForm->m_pFormNotify->AfterValueChange(this);
         }
     }
-    m_pForm->m_bUpdated = TRUE;
-    return TRUE;
+    m_pForm->m_bUpdated = true;
+    return true;
 }
 void CPDF_FormField::LoadDA()
 {
diff --git a/core/src/fpdfdoc/doc_metadata.cpp b/core/src/fpdfdoc/doc_metadata.cpp
index aeeb1d1f60..33e1e23d0f 100644
--- a/core/src/fpdfdoc/doc_metadata.cpp
+++ b/core/src/fpdfdoc/doc_metadata.cpp
@@ -58,7 +58,7 @@ void CPDF_Metadata::LoadDoc(CPDF_Document *pDoc)
         return;
     }
     CPDF_StreamAcc acc;
-    acc.LoadAllData(pStream, FALSE);
+    acc.LoadAllData(pStream, false);
     int size = acc.GetSize();
     const uint8_t* pBuf = acc.GetData();
     CXML_Element *&pXmlElmnt = ((PDFDOC_LPMETADATA)m_pData)->m_pXmlElmnt;
diff --git a/core/src/fpdfdoc/doc_ocg.cpp b/core/src/fpdfdoc/doc_ocg.cpp
index d525227219..6e88309fee 100644
--- a/core/src/fpdfdoc/doc_ocg.cpp
+++ b/core/src/fpdfdoc/doc_ocg.cpp
@@ -25,7 +25,7 @@ static int32_t FPDFDOC_OCG_FindGroup(const CPDF_Object *pObject, const CPDF_Dict
     }
     return -1;
 }
-static FX_BOOL FPDFDOC_OCG_HasIntent(const CPDF_Dictionary *pDict, const CFX_ByteStringC& csElement, const CFX_ByteStringC& csDef = FX_BSTRC(""))
+static bool FPDFDOC_OCG_HasIntent(const CPDF_Dictionary *pDict, const CFX_ByteStringC& csElement, const CFX_ByteStringC& csDef = FX_BSTRC(""))
 {
     FXSYS_assert(pDict != NULL);
     CPDF_Object *pIntent = pDict->GetElementValue(FX_BSTRC("Intent"));
@@ -38,10 +38,10 @@ static FX_BOOL FPDFDOC_OCG_HasIntent(const CPDF_Dictionary *pDict, const CFX_Byt
         for (FX_DWORD i = 0; i < dwCount; i++) {
             bsIntent = ((CPDF_Array*)pIntent)->GetString(i);
             if (bsIntent == FX_BSTRC("All") || bsIntent == csElement) {
-                return TRUE;
+                return true;
             }
         }
-        return FALSE;
+        return false;
     }
     bsIntent = pIntent->GetString();
     return bsIntent == FX_BSTRC("All") || bsIntent == csElement;
@@ -101,24 +101,24 @@ CPDF_OCContext::~CPDF_OCContext()
 {
     m_OCGStates.clear();
 }
-FX_BOOL CPDF_OCContext::LoadOCGStateFromConfig(const CFX_ByteStringC& csConfig, const CPDF_Dictionary *pOCGDict, FX_BOOL &bValidConfig) const
+bool CPDF_OCContext::LoadOCGStateFromConfig(const CFX_ByteStringC& csConfig, const CPDF_Dictionary *pOCGDict, bool &bValidConfig) const
 {
     CPDF_Dictionary *pConfig = FPDFDOC_OCG_GetConfig(m_pDocument, pOCGDict, csConfig);
     if (!pConfig) {
-        return TRUE;
+        return true;
     }
-    bValidConfig = TRUE;
-    FX_BOOL bState = pConfig->GetString(FX_BSTRC("BaseState"), FX_BSTRC("ON")) != FX_BSTRC("OFF");
+    bValidConfig = true;
+    bool bState = pConfig->GetString(FX_BSTRC("BaseState"), FX_BSTRC("ON")) != FX_BSTRC("OFF");
     CPDF_Array *pArray = pConfig->GetArray(FX_BSTRC("ON"));
     if (pArray) {
         if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
-            bState = TRUE;
+            bState = true;
         }
     }
     pArray = pConfig->GetArray(FX_BSTRC("OFF"));
     if (pArray) {
         if (FPDFDOC_OCG_FindGroup(pArray, pOCGDict) >= 0) {
-            bState = FALSE;
+            bState = false;
         }
     }
     pArray = pConfig->GetArray(FX_BSTRC("AS"));
@@ -149,10 +149,10 @@ FX_BOOL CPDF_OCContext::LoadOCGStateFromConfig(const CFX_ByteStringC& csConfig,
     }
     return bState;
 }
-FX_BOOL CPDF_OCContext::LoadOCGState(const CPDF_Dictionary *pOCGDict) const
+bool CPDF_OCContext::LoadOCGState(const CPDF_Dictionary *pOCGDict) const
 {
     if (!FPDFDOC_OCG_HasIntent(pOCGDict, FX_BSTRC("View"), FX_BSTRC("View"))) {
-        return TRUE;
+        return true;
     }
     CFX_ByteString csState = FPDFDOC_OCG_GetUsageTypeString(m_eUsageType);
     CPDF_Dictionary *pUsage = pOCGDict->GetDict(FX_BSTRC("Usage"));
@@ -171,31 +171,31 @@ FX_BOOL CPDF_OCContext::LoadOCGState(const CPDF_Dictionary *pOCGDict) const
             }
         }
     }
-    FX_BOOL bDefValid = FALSE;
+    bool bDefValid = false;
     return LoadOCGStateFromConfig(csState, pOCGDict, bDefValid);
 }
 
-FX_BOOL CPDF_OCContext::GetOCGVisible(const CPDF_Dictionary* pOCGDict)
+bool CPDF_OCContext::GetOCGVisible(const CPDF_Dictionary* pOCGDict)
 {
     if (!pOCGDict)
-        return FALSE;
+        return false;
 
     const auto it = m_OCGStates.find(pOCGDict);
     if (it != m_OCGStates.end())
         return it->second;
 
-    FX_BOOL bState = LoadOCGState(pOCGDict);
+    bool bState = LoadOCGState(pOCGDict);
     m_OCGStates[pOCGDict] = bState;
     return bState;
 }
 
-FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, int nLevel)
+bool CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, bool bFromConfig, int nLevel)
 {
     if (nLevel > 32) {
-        return FALSE;
+        return false;
     }
     if (pExpression == NULL) {
-        return FALSE;
+        return false;
     }
     int32_t iCount = pExpression->GetCount();
     CPDF_Object *pOCGObj;
@@ -203,7 +203,7 @@ FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, i
     if (csOperator == FX_BSTRC("Not")) {
         pOCGObj = pExpression->GetElementValue(1);
         if (pOCGObj == NULL) {
-            return FALSE;
+            return false;
         }
         if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) {
             return !(bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj));
@@ -211,16 +211,16 @@ FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, i
         if (pOCGObj->GetType() == PDFOBJ_ARRAY) {
             return !GetOCGVE((CPDF_Array*)pOCGObj, bFromConfig, nLevel + 1);
         }
-        return FALSE;
+        return false;
     }
     if (csOperator == FX_BSTRC("Or") || csOperator == FX_BSTRC("And")) {
-        FX_BOOL bValue = FALSE;
+        bool bValue = false;
         for (int32_t i = 1; i < iCount; i ++) {
             pOCGObj = pExpression->GetElementValue(1);
             if (pOCGObj == NULL) {
                 continue;
             }
-            FX_BOOL bItem = FALSE;
+            bool bItem = false;
             if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) {
                 bItem = bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj);
             } else if (pOCGObj->GetType() == PDFOBJ_ARRAY) {
@@ -238,9 +238,9 @@ FX_BOOL CPDF_OCContext::GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, i
         }
         return bValue;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_OCContext::LoadOCMDState(const CPDF_Dictionary *pOCMDDict, FX_BOOL bFromConfig)
+bool CPDF_OCContext::LoadOCMDState(const CPDF_Dictionary *pOCMDDict, bool bFromConfig)
 {
     FXSYS_assert(pOCMDDict != NULL);
     CPDF_Array *pVE = pOCMDDict->GetArray(FX_BSTRC("VE"));
@@ -250,50 +250,50 @@ FX_BOOL CPDF_OCContext::LoadOCMDState(const CPDF_Dictionary *pOCMDDict, FX_BOOL
     CFX_ByteString csP = pOCMDDict->GetString(FX_BSTRC("P"), FX_BSTRC("AnyOn"));
     CPDF_Object *pOCGObj = pOCMDDict->GetElementValue(FX_BSTRC("OCGs"));
     if (pOCGObj == NULL) {
-        return TRUE;
+        return true;
     }
     if (pOCGObj->GetType() == PDFOBJ_DICTIONARY) {
         return bFromConfig ? LoadOCGState((CPDF_Dictionary*)pOCGObj) : GetOCGVisible((CPDF_Dictionary*)pOCGObj);
     }
     if (pOCGObj->GetType() != PDFOBJ_ARRAY) {
-        return TRUE;
+        return true;
     }
-    FX_BOOL bState = FALSE;
+    bool bState = false;
     if (csP == FX_BSTRC("AllOn") || csP == FX_BSTRC("AllOff")) {
-        bState = TRUE;
+        bState = true;
     }
     int32_t iCount = ((CPDF_Array*)pOCGObj)->GetCount();
     for (int32_t i = 0; i < iCount; i ++) {
-        FX_BOOL bItem = TRUE;
+        bool bItem = true;
         CPDF_Dictionary* pItemDict = ((CPDF_Array*)pOCGObj)->GetDict(i);
         if (pItemDict) {
             bItem = bFromConfig ? LoadOCGState(pItemDict) : GetOCGVisible(pItemDict);
         }
         if (csP == FX_BSTRC("AnyOn") && bItem) {
-            return TRUE;
+            return true;
         }
         if (csP == FX_BSTRC("AnyOff") && !bItem) {
-            return TRUE;
+            return true;
         }
         if (csP == FX_BSTRC("AllOn") && !bItem) {
-            return FALSE;
+            return false;
         }
         if (csP == FX_BSTRC("AllOff") && bItem) {
-            return FALSE;
+            return false;
         }
     }
     return bState;
 }
-FX_BOOL CPDF_OCContext::CheckOCGVisible(const CPDF_Dictionary *pOCGDict)
+bool CPDF_OCContext::CheckOCGVisible(const CPDF_Dictionary *pOCGDict)
 {
     if (!pOCGDict) {
-        return TRUE;
+        return true;
     }
     CFX_ByteString csType = pOCGDict->GetString(FX_BSTRC("Type"), FX_BSTRC("OCG"));
     if (csType == FX_BSTRC("OCG")) {
         return GetOCGVisible(pOCGDict);
     }
-    return LoadOCMDState(pOCGDict, FALSE);
+    return LoadOCMDState(pOCGDict, false);
 }
 void CPDF_OCContext::ResetOCContext()
 {
diff --git a/core/src/fpdfdoc/doc_tagged.cpp b/core/src/fpdfdoc/doc_tagged.cpp
index e9f0c55e2b..3e44b1ac9b 100644
--- a/core/src/fpdfdoc/doc_tagged.cpp
+++ b/core/src/fpdfdoc/doc_tagged.cpp
@@ -9,7 +9,7 @@
 #include "../../include/fpdfdoc/fpdf_tagged.h"
 #include "tagged_int.h"
 const int nMaxRecursion = 32;
-static FX_BOOL IsTagged(const CPDF_Document* pDoc)
+static bool IsTagged(const CPDF_Document* pDoc)
 {
     CPDF_Dictionary* pCatalog = pDoc->GetRoot();
     CPDF_Dictionary* pMarkInfo = pCatalog->GetDict(FX_BSTRC("MarkInfo"));
@@ -138,7 +138,7 @@ CPDF_StructElementImpl* CPDF_StructTreeImpl::AddPageNode(CPDF_Dictionary* pDict,
         }
     } else {
         CPDF_StructElementImpl* pParentElement = AddPageNode(pParent, map, nLevel + 1);
-        FX_BOOL bSave = FALSE;
+        bool bSave = false;
         for (int i = 0; i < pParentElement->m_Kids.GetSize(); i ++) {
             if (pParentElement->m_Kids[i].m_Type != CPDF_StructKid::Element) {
                 continue;
@@ -147,7 +147,7 @@ CPDF_StructElementImpl* CPDF_StructTreeImpl::AddPageNode(CPDF_Dictionary* pDict,
                 continue;
             }
             pParentElement->m_Kids[i].m_Element.m_pElement = pElement->Retain();
-            bSave = TRUE;
+            bSave = true;
         }
         if (!bSave) {
             pElement->Release();
@@ -156,11 +156,11 @@ CPDF_StructElementImpl* CPDF_StructTreeImpl::AddPageNode(CPDF_Dictionary* pDict,
     }
     return pElement;
 }
-FX_BOOL CPDF_StructTreeImpl::AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_StructElementImpl* pElement)
+bool CPDF_StructTreeImpl::AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_StructElementImpl* pElement)
 {
     CPDF_Object *pObj = m_pTreeRoot->GetElementValue(FX_BSTRC("K"));
     if (!pObj) {
-        return FALSE;
+        return false;
     }
     if (pObj->GetType() == PDFOBJ_DICTIONARY) {
         if (pObj->GetObjNum() == pDict->GetObjNum()) {
@@ -169,13 +169,13 @@ FX_BOOL CPDF_StructTreeImpl::AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_Struct
             }
             m_Kids[0] = pElement->Retain();
         } else {
-            return FALSE;
+            return false;
         }
     }
     if (pObj->GetType() == PDFOBJ_ARRAY) {
         CPDF_Array* pTopKids = (CPDF_Array*)pObj;
         FX_DWORD i;
-        FX_BOOL bSave = FALSE;
+        bool bSave = false;
         for (i = 0; i < pTopKids->GetCount(); i ++) {
             CPDF_Object* pKidRef = pTopKids->GetElement(i);
             if (pKidRef == NULL || pKidRef->GetType() != PDFOBJ_REFERENCE) {
@@ -188,13 +188,13 @@ FX_BOOL CPDF_StructTreeImpl::AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_Struct
                 m_Kids[i]->Release();
             }
             m_Kids[i] = pElement->Retain();
-            bSave = TRUE;
+            bSave = true;
         }
         if (!bSave) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 CPDF_StructElementImpl::CPDF_StructElementImpl(CPDF_StructTreeImpl* pTree, CPDF_StructElementImpl* pParent, CPDF_Dictionary* pDict)
     : m_RefCount(0)
@@ -340,20 +340,20 @@ static CPDF_Dictionary* FindAttrDict(CPDF_Object* pAttrs, const CFX_ByteStringC&
     }
     return NULL;
 }
-CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_BOOL bInheritable, FX_FLOAT fLevel)
+CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, bool bInheritable, FX_FLOAT fLevel)
 {
     if (fLevel > nMaxRecursion) {
         return NULL;
     }
     if (bInheritable) {
-        CPDF_Object* pAttr = GetAttr(owner, name, FALSE);
+        CPDF_Object* pAttr = GetAttr(owner, name, false);
         if (pAttr) {
             return pAttr;
         }
         if (m_pParent == NULL) {
             return NULL;
         }
-        return m_pParent->GetAttr(owner, name, TRUE, fLevel + 1);
+        return m_pParent->GetAttr(owner, name, true, fLevel + 1);
     }
     CPDF_Object* pA = m_pDict->GetElementValue(FX_BSTRC("A"));
     if (pA) {
@@ -391,7 +391,7 @@ CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const
     }
     return NULL;
 }
-CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_BOOL bInheritable, int subindex)
+CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, bool bInheritable, int subindex)
 {
     CPDF_Object* pAttr = GetAttr(owner, name, bInheritable);
     if (pAttr == NULL || subindex == -1 || pAttr->GetType() != PDFOBJ_ARRAY) {
@@ -403,7 +403,7 @@ CPDF_Object* CPDF_StructElementImpl::GetAttr(const CFX_ByteStringC& owner, const
     }
     return pArray->GetElementValue(subindex);
 }
-CFX_ByteString CPDF_StructElementImpl::GetName(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, const CFX_ByteStringC& default_value, FX_BOOL bInheritable, int subindex)
+CFX_ByteString CPDF_StructElementImpl::GetName(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, const CFX_ByteStringC& default_value, bool bInheritable, int subindex)
 {
     CPDF_Object* pAttr = GetAttr(owner, name, bInheritable, subindex);
     if (pAttr == NULL || pAttr->GetType() != PDFOBJ_NAME) {
@@ -411,7 +411,7 @@ CFX_ByteString CPDF_StructElementImpl::GetName(const CFX_ByteStringC& owner, con
     }
     return pAttr->GetString();
 }
-FX_ARGB	CPDF_StructElementImpl::GetColor(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_ARGB default_value, FX_BOOL bInheritable, int subindex)
+FX_ARGB	CPDF_StructElementImpl::GetColor(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_ARGB default_value, bool bInheritable, int subindex)
 {
     CPDF_Object* pAttr = GetAttr(owner, name, bInheritable, subindex);
     if (pAttr == NULL || pAttr->GetType() != PDFOBJ_ARRAY) {
@@ -420,7 +420,7 @@ FX_ARGB	CPDF_StructElementImpl::GetColor(const CFX_ByteStringC& owner, const CFX
     CPDF_Array* pArray = (CPDF_Array*)pAttr;
     return 0xff000000 | ((int)(pArray->GetNumber(0) * 255) << 16) | ((int)(pArray->GetNumber(1) * 255) << 8) | (int)(pArray->GetNumber(2) * 255);
 }
-FX_FLOAT CPDF_StructElementImpl::GetNumber(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_FLOAT default_value, FX_BOOL bInheritable, int subindex)
+FX_FLOAT CPDF_StructElementImpl::GetNumber(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_FLOAT default_value, bool bInheritable, int subindex)
 {
     CPDF_Object* pAttr = GetAttr(owner, name, bInheritable, subindex);
     if (pAttr == NULL || pAttr->GetType() != PDFOBJ_NUMBER) {
@@ -428,7 +428,7 @@ FX_FLOAT CPDF_StructElementImpl::GetNumber(const CFX_ByteStringC& owner, const C
     }
     return pAttr->GetNumber();
 }
-int	CPDF_StructElementImpl::GetInteger(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, int default_value, FX_BOOL bInheritable, int subindex)
+int	CPDF_StructElementImpl::GetInteger(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, int default_value, bool bInheritable, int subindex)
 {
     CPDF_Object* pAttr = GetAttr(owner, name, bInheritable, subindex);
     if (pAttr == NULL || pAttr->GetType() != PDFOBJ_NUMBER) {
diff --git a/core/src/fpdfdoc/doc_utils.cpp b/core/src/fpdfdoc/doc_utils.cpp
index 96d2ccf689..26c93f1791 100644
--- a/core/src/fpdfdoc/doc_utils.cpp
+++ b/core/src/fpdfdoc/doc_utils.cpp
@@ -26,10 +26,10 @@ CFX_WideString GetFullName(CPDF_Dictionary* pFieldDict)
     }
     return full_name;
 }
-FX_BOOL CPDF_DefaultAppearance::HasFont()
+bool CPDF_DefaultAppearance::HasFont()
 {
     if (m_csDA.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CPDF_SimpleParser syntax(m_csDA);
     return syntax.FindTagParam("Tf", 2);
@@ -65,23 +65,23 @@ void CPDF_DefaultAppearance::GetFont(CFX_ByteString& csFontNameTag, FX_FLOAT& fF
     }
     csFontNameTag = PDF_NameDecode(csFontNameTag);
 }
-FX_BOOL CPDF_DefaultAppearance::HasColor(FX_BOOL bStrokingOperation)
+bool CPDF_DefaultAppearance::HasColor(bool bStrokingOperation)
 {
     if (m_csDA.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CPDF_SimpleParser syntax(m_csDA);
     if (syntax.FindTagParam(bStrokingOperation ? "G" : "g", 1)) {
-        return TRUE;
+        return true;
     }
     syntax.SetPos(0);
     if (syntax.FindTagParam(bStrokingOperation ? "RG" : "rg", 3)) {
-        return TRUE;
+        return true;
     }
     syntax.SetPos(0);
     return syntax.FindTagParam(bStrokingOperation ? "K" : "k", 4);
 }
-CFX_ByteString CPDF_DefaultAppearance::GetColorString(FX_BOOL bStrokingOperation)
+CFX_ByteString CPDF_DefaultAppearance::GetColorString(bool bStrokingOperation)
 {
     CFX_ByteString csColor;
     if (m_csDA.IsEmpty()) {
@@ -119,7 +119,7 @@ CFX_ByteString CPDF_DefaultAppearance::GetColorString(FX_BOOL bStrokingOperation
     }
     return csColor;
 }
-void CPDF_DefaultAppearance::GetColor(int& iColorType, FX_FLOAT fc[4], FX_BOOL bStrokingOperation)
+void CPDF_DefaultAppearance::GetColor(int& iColorType, FX_FLOAT fc[4], bool bStrokingOperation)
 {
     iColorType = COLORTYPE_TRANSPARENT;
     for (int c = 0; c < 4; c ++) {
@@ -151,7 +151,7 @@ void CPDF_DefaultAppearance::GetColor(int& iColorType, FX_FLOAT fc[4], FX_BOOL b
         fc[3] = FX_atof((CFX_ByteString)syntax.GetWord());
     }
 }
-void CPDF_DefaultAppearance::GetColor(FX_ARGB& color, int& iColorType, FX_BOOL bStrokingOperation)
+void CPDF_DefaultAppearance::GetColor(FX_ARGB& color, int& iColorType, bool bStrokingOperation)
 {
     color = 0;
     iColorType = COLORTYPE_TRANSPARENT;
@@ -187,10 +187,10 @@ void CPDF_DefaultAppearance::GetColor(FX_ARGB& color, int& iColorType, FX_BOOL b
         color = ArgbEncode(255, (int)(r * 255 + 0.5f), (int)(g * 255 + 0.5f), (int)(b * 255 + 0.5f));
     }
 }
-FX_BOOL CPDF_DefaultAppearance::HasTextMatrix()
+bool CPDF_DefaultAppearance::HasTextMatrix()
 {
     if (m_csDA.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     CPDF_SimpleParser syntax(m_csDA);
     return syntax.FindTagParam("Tm", 6);
@@ -468,18 +468,18 @@ CPDF_Font* GetNativeInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDo
     }
     return GetNativeInterFormFont(pFormDict, pDocument, charSet, csNameTag);
 }
-FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CFX_ByteString& csNameTag)
+bool FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CFX_ByteString& csNameTag)
 {
     if (pFormDict == NULL || pFont == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
     if (pDR == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pFonts = pDR->GetDict("Font");
     if (pFonts == NULL) {
-        return FALSE;
+        return false;
     }
     FX_POSITION pos = pFonts->GetStartPos();
     while (pos) {
@@ -499,23 +499,23 @@ FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CF
         }
         if (pFont->GetFontDict() == pElement) {
             csNameTag = csKey;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag)
+bool FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag)
 {
     if (pFormDict == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pDR = pFormDict->GetDict("DR");
     if (pDR == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pFonts = pDR->GetDict("Font");
     if (pFonts == NULL) {
-        return FALSE;
+        return false;
     }
     if (csFontName.GetLength() > 0) {
         csFontName.Remove(' ');
@@ -545,10 +545,10 @@ FX_BOOL FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument,
         csBaseFont.Remove(' ');
         if (csBaseFont == csFontName) {
             csNameTag = csKey;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 void AddInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, const CPDF_Font* pFont, CFX_ByteString& csNameTag)
 {
@@ -670,10 +670,10 @@ CPDF_IconFit::ScaleMethod CPDF_IconFit::GetScaleMethod()
     }
     return Always;
 }
-FX_BOOL CPDF_IconFit::IsProportionalScale()
+bool CPDF_IconFit::IsProportionalScale()
 {
     if (m_pDict == NULL) {
-        return TRUE;
+        return true;
     }
     return m_pDict->GetString("S", "P") != "A";
 }
@@ -694,10 +694,10 @@ void CPDF_IconFit::GetIconPosition(FX_FLOAT& fLeft, FX_FLOAT& fBottom)
         }
     }
 }
-FX_BOOL CPDF_IconFit::GetFittingBounds()
+bool CPDF_IconFit::GetFittingBounds()
 {
     if (m_pDict == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pDict->GetBoolean("FB");
 }
diff --git a/core/src/fpdfdoc/doc_utils.h b/core/src/fpdfdoc/doc_utils.h
index 6bb1d30dbb..6dcf5b0d28 100644
--- a/core/src/fpdfdoc/doc_utils.h
+++ b/core/src/fpdfdoc/doc_utils.h
@@ -15,8 +15,8 @@ CPDF_Font*		GetInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocumen
 CPDF_Font*		GetInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CFX_ByteString& csNameTag);
 CPDF_Font*		GetNativeInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, uint8_t charSet, CFX_ByteString& csNameTag);
 CPDF_Font*		GetNativeInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString& csNameTag);
-FX_BOOL			FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CFX_ByteString& csNameTag);
-FX_BOOL			FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag);
+bool			FindInterFormFont(CPDF_Dictionary* pFormDict, const CPDF_Font* pFont, CFX_ByteString& csNameTag);
+bool			FindInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument, CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag);
 void			AddInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, const CPDF_Font* pFont, CFX_ByteString& csNameTag);
 CPDF_Font*		AddNativeInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, uint8_t charSet, CFX_ByteString& csNameTag);
 CPDF_Font*		AddNativeInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, CFX_ByteString& csNameTag);
@@ -25,8 +25,8 @@ void			RemoveInterFormFont(CPDF_Dictionary* pFormDict, CFX_ByteString csNameTag)
 CPDF_Font*		GetDefaultInterFormFont(CPDF_Dictionary* pFormDict, CPDF_Document* pDocument);
 void			SetDefaultInterFormFont(CPDF_Dictionary*& pFormDict, CPDF_Document* pDocument, const CPDF_Font* pFont);
 void			SaveCheckedFieldStatus(CPDF_FormField* pField, CFX_ByteArray& statusArray);
-FX_BOOL			NeedPDFEncodeForFieldFullName(const CFX_WideString& csFieldName);
-FX_BOOL			NeedPDFEncodeForFieldTree(CPDF_Dictionary* pFieldDict, int nLevel = 0);
+bool			NeedPDFEncodeForFieldFullName(const CFX_WideString& csFieldName);
+bool			NeedPDFEncodeForFieldTree(CPDF_Dictionary* pFieldDict, int nLevel = 0);
 void			EncodeFieldName(const CFX_WideString& csName, CFX_ByteString& csT);
 void			UpdateEncodeFieldName(CPDF_Dictionary* pFieldDict, int nLevel = 0);
 
diff --git a/core/src/fpdfdoc/doc_viewerPreferences.cpp b/core/src/fpdfdoc/doc_viewerPreferences.cpp
index eb824eb5a4..1c014dbd38 100644
--- a/core/src/fpdfdoc/doc_viewerPreferences.cpp
+++ b/core/src/fpdfdoc/doc_viewerPreferences.cpp
@@ -11,21 +11,21 @@ CPDF_ViewerPreferences::CPDF_ViewerPreferences(CPDF_Document *pDoc): m_pDoc(pDoc
 CPDF_ViewerPreferences::~CPDF_ViewerPreferences()
 {
 }
-FX_BOOL CPDF_ViewerPreferences::IsDirectionR2L() const
+bool CPDF_ViewerPreferences::IsDirectionR2L() const
 {
     CPDF_Dictionary *pDict = m_pDoc->GetRoot();
     pDict = pDict->GetDict(FX_BSTRC("ViewerPreferences"));
     if (!pDict)	{
-        return FALSE;
+        return false;
     }
     return FX_BSTRC("R2L") == pDict->GetString(FX_BSTRC("Direction"));
 }
-FX_BOOL CPDF_ViewerPreferences::PrintScaling() const
+bool CPDF_ViewerPreferences::PrintScaling() const
 {
     CPDF_Dictionary *pDict = m_pDoc->GetRoot();
     pDict = pDict->GetDict(FX_BSTRC("ViewerPreferences"));
     if (!pDict)	{
-        return TRUE;
+        return true;
     }
     return FX_BSTRC("None") != pDict->GetString(FX_BSTRC("PrintScaling"));
 }
diff --git a/core/src/fpdfdoc/doc_vt.cpp b/core/src/fpdfdoc/doc_vt.cpp
index 230ba764e4..8cc6b7c9f5 100644
--- a/core/src/fpdfdoc/doc_vt.cpp
+++ b/core/src/fpdfdoc/doc_vt.cpp
@@ -183,8 +183,8 @@ CPVT_WordPlace CSection::SearchWordPlace(const CPDF_Point & point) const
 {
     ASSERT(m_pVT != NULL);
     CPVT_WordPlace place = GetBeginWordPlace();
-    FX_BOOL bUp = TRUE;
-    FX_BOOL bDown = TRUE;
+    bool bUp = true;
+    bool bDown = true;
     int32_t nLeft = 0;
     int32_t nRight = m_LineArray.GetSize() - 1;
     int32_t nMid = m_LineArray.GetSize() / 2;
@@ -195,10 +195,10 @@ CPVT_WordPlace CSection::SearchWordPlace(const CPDF_Point & point) const
             fTop = pLine->m_LineInfo.fLineY - pLine->m_LineInfo.fLineAscent - m_pVT->GetLineLeading(m_SecInfo);
             fBottom = pLine->m_LineInfo.fLineY - pLine->m_LineInfo.fLineDescent;
             if (IsFloatBigger(point.y, fTop)) {
-                bUp = FALSE;
+                bUp = false;
             }
             if (IsFloatSmaller(point.y, fBottom)) {
-                bDown = FALSE;
+                bDown = false;
             }
             if (IsFloatSmaller(point.y, fTop)) {
                 nRight = nMid - 1;
@@ -394,7 +394,7 @@ CPVT_Size CTypeset::GetEditSize(FX_FLOAT fFontSize)
 {
     ASSERT(m_pSection != NULL);
     ASSERT(m_pVT != NULL);
-    SplitLines(FALSE, fFontSize);
+    SplitLines(false, fFontSize);
     return CPVT_Size(m_rcRet.Width(), m_rcRet.Height());
 }
 CPVT_FloatRect CTypeset::Typeset()
@@ -402,7 +402,7 @@ CPVT_FloatRect CTypeset::Typeset()
     ASSERT(m_pSection != NULL);
     ASSERT(m_pVT != NULL);
     m_pSection->m_LineArray.Empty();
-    SplitLines(TRUE, 0.0f);
+    SplitLines(true, 0.0f);
     m_pSection->m_LineArray.Clear();
     OutputLines();
     return m_rcRet;
@@ -425,11 +425,11 @@ static int special_chars[128] = {
     0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
     0x0001, 0x0001, 0x0001, 0x000C, 0x0000, 0x0008, 0x0000, 0x0000,
 };
-static FX_BOOL IsLatin(FX_WORD word)
+static bool IsLatin(FX_WORD word)
 {
     if (word <= 0x007F) {
         if (special_chars[word] & 0x0001) {
-            return TRUE;
+            return true;
         }
     }
     if ((word >= 0x00C0 && word <= 0x00FF) ||
@@ -439,15 +439,15 @@ static FX_BOOL IsLatin(FX_WORD word)
             (word >= 0xA720 && word <= 0xA7FF) ||
             (word >= 0xFF21 && word <= 0xFF3A) ||
             (word >= 0xFF41 && word <= 0xFF5A)) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsDigit(FX_DWORD word)
+static bool IsDigit(FX_DWORD word)
 {
-    return (word >= 0x0030 && word <= 0x0039) ? TRUE : FALSE;
+    return (word >= 0x0030 && word <= 0x0039) ? true : false;
 }
-static FX_BOOL IsCJK(FX_DWORD word)
+static bool IsCJK(FX_DWORD word)
 {
     if ((word >= 0x1100 && word <= 0x11FF) ||
             (word >= 0x2E80 && word <= 0x2FFF) ||
@@ -457,33 +457,33 @@ static FX_BOOL IsCJK(FX_DWORD word)
             (word >= 0xFE30 && word <= 0xFE4F) ||
             (word >= 0x20000 && word <= 0x2A6DF) ||
             (word >= 0x2F800 && word <= 0x2FA1F)) {
-        return TRUE;
+        return true;
     }
     if (word >= 0x3000 && word <= 0x303F) {
         if (word == 0x3005 || word == 0x3006 || word == 0x3021 || word == 0x3022 ||
                 word == 0x3023 || word == 0x3024 || word == 0x3025 || word == 0x3026 ||
                 word == 0x3027 || word == 0x3028 || word == 0x3029 || word == 0x3031 ||
                 word == 0x3032 || word == 0x3033 || word == 0x3034 || word == 0x3035) {
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     if (word >= 0xFF66 && word <= 0xFF9D) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsPunctuation(FX_DWORD word)
+static bool IsPunctuation(FX_DWORD word)
 {
     if (word <= 0x007F) {
         if ((special_chars[word] >> 3) & 1) {
-            return TRUE;
+            return true;
         }
     } else if (word >= 0x0080 && word <= 0x00FF) {
         if (word == 0x0082 || word == 0x0084 || word == 0x0085 || word == 0x0091 ||
                 word == 0x0092 || word == 0x0093 || word <= 0x0094 || word == 0x0096 ||
                 word == 0x00B4 || word == 0x00B8) {
-            return TRUE;
+            return true;
         }
     } else if (word >= 0x2000 && word <= 0x206F) {
         if (word == 0x2010 || word == 0x2011 || word == 0x2012 || word == 0x2013 ||
@@ -492,7 +492,7 @@ static FX_BOOL IsPunctuation(FX_DWORD word)
                 word == 0x2032 || word == 0x2033 || word == 0x2034 || word == 0x2035 ||
                 word == 0x2036 || word == 0x2037 || word == 0x203C || word == 0x203D ||
                 word == 0x203E || word == 0x2044) {
-            return TRUE;
+            return true;
         }
     } else if (word >= 0x3000 && word <= 0x303F) {
         if (word == 0x3001 || word == 0x3002 || word == 0x3003 || word == 0x3005 ||
@@ -501,11 +501,11 @@ static FX_BOOL IsPunctuation(FX_DWORD word)
                 word == 0x3011 || word == 0x3014 || word == 0x3015 || word == 0x3016 ||
                 word == 0x3017 || word == 0x3018 || word == 0x3019 || word == 0x301A ||
                 word == 0x301B || word == 0x301D || word == 0x301E || word == 0x301F) {
-            return TRUE;
+            return true;
         }
     } else if (word >= 0xFE50 && word <= 0xFE6F) {
         if ((word >= 0xFE50 && word <= 0xFE5E) || word == 0xFE63) {
-            return TRUE;
+            return true;
         }
     } else if (word >= 0xFF00 && word <= 0xFFEF) {
         if (word == 0xFF01 || word == 0xFF02 || word == 0xFF07 || word == 0xFF08 ||
@@ -514,83 +514,83 @@ static FX_BOOL IsPunctuation(FX_DWORD word)
                 word == 0xFF3D || word == 0xFF40 || word == 0xFF5B || word == 0xFF5C ||
                 word == 0xFF5D || word == 0xFF61 || word == 0xFF62 || word == 0xFF63 ||
                 word == 0xFF64 || word == 0xFF65 || word == 0xFF9E || word == 0xFF9F) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsConnectiveSymbol(FX_DWORD word)
+static bool IsConnectiveSymbol(FX_DWORD word)
 {
     if (word <= 0x007F) {
         if ((special_chars[word] >> 5) & 1) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsOpenStylePunctuation(FX_DWORD word)
+static bool IsOpenStylePunctuation(FX_DWORD word)
 {
     if (word <= 0x007F) {
         if ((special_chars[word] >> 2) & 1) {
-            return TRUE;
+            return true;
         }
     } else if (word == 0x300A || word == 0x300C || word == 0x300E || word == 0x3010 ||
                word == 0x3014 || word == 0x3016 || word == 0x3018 || word == 0x301A ||
                word == 0xFF08 || word == 0xFF3B || word == 0xFF5B || word == 0xFF62) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsCurrencySymbol(FX_WORD word)
+static bool IsCurrencySymbol(FX_WORD word)
 {
     if (word == 0x0024 || word == 0x0080 || word == 0x00A2 || word == 0x00A3 ||
             word == 0x00A4 || word == 0x00A5 || (word >= 0x20A0 && word <= 0x20CF) ||
             word == 0xFE69 || word == 0xFF04 || word == 0xFFE0 || word == 0xFFE1 ||
             word == 0xFFE5 || word == 0xFFE6) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsPrefixSymbol(FX_WORD word)
+static bool IsPrefixSymbol(FX_WORD word)
 {
     if (IsCurrencySymbol(word)) {
-        return TRUE;
+        return true;
     }
     if (word == 0x2116) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-static FX_BOOL IsSpace(FX_WORD word)
+static bool IsSpace(FX_WORD word)
 {
-    return (word == 0x0020 || word == 0x3000) ? TRUE : FALSE;
+    return (word == 0x0020 || word == 0x3000) ? true : false;
 }
-static FX_BOOL NeedDivision(FX_WORD prevWord, FX_WORD curWord)
+static bool NeedDivision(FX_WORD prevWord, FX_WORD curWord)
 {
     if ((IsLatin(prevWord) || IsDigit(prevWord)) && (IsLatin(curWord) || IsDigit(curWord))) {
-        return FALSE;
+        return false;
     }
     if (IsSpace(curWord) || IsPunctuation(curWord)) {
-        return FALSE;
+        return false;
     }
     if (IsConnectiveSymbol(prevWord) || IsConnectiveSymbol(curWord)) {
-        return FALSE;
+        return false;
     }
     if (IsSpace(prevWord) || IsPunctuation(prevWord)) {
-        return TRUE;
+        return true;
     }
     if (IsPrefixSymbol(prevWord)) {
-        return FALSE;
+        return false;
     }
     if (IsPrefixSymbol(curWord) || IsCJK(curWord)) {
-        return TRUE;
+        return true;
     }
     if (IsCJK(prevWord)) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-void CTypeset::SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize)
+void CTypeset::SplitLines(bool bTypeset, FX_FLOAT fFontSize)
 {
     ASSERT(m_pVT != NULL);
     ASSERT(m_pSection != NULL);
@@ -601,14 +601,14 @@ void CTypeset::SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize)
     FX_FLOAT fLineAscent = 0.0f, fBackupLineAscent = 0.0f;
     FX_FLOAT fLineDescent = 0.0f, fBackupLineDescent = 0.0f;
     int32_t nWordStartPos = 0;
-    FX_BOOL bFullWord = FALSE;
+    bool bFullWord = false;
     int32_t nLineFullWordIndex = 0;
     int32_t nCharIndex = 0;
     CPVT_LineInfo line;
     FX_FLOAT fWordWidth = 0;
     FX_FLOAT fTypesetWidth = FPDF_MAX(m_pVT->GetPlateWidth() - m_pVT->GetLineIndent(m_pSection->m_SecInfo), 0.0f);
     int32_t nTotalWords = m_pSection->m_WordArray.GetSize();
-    FX_BOOL bOpened = FALSE;
+    bool bOpened = false;
     if (nTotalWords > 0) {
         int32_t i = 0;
         while (i < nTotalWords) {
@@ -619,8 +619,8 @@ void CTypeset::SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize)
             }
             if (pWord) {
                 if (bTypeset) {
-                    fLineAscent = FPDF_MAX(fLineAscent, m_pVT->GetWordAscent(*pWord, TRUE));
-                    fLineDescent = FPDF_MIN(fLineDescent, m_pVT->GetWordDescent(*pWord, TRUE));
+                    fLineAscent = FPDF_MAX(fLineAscent, m_pVT->GetWordAscent(*pWord, true));
+                    fLineDescent = FPDF_MIN(fLineDescent, m_pVT->GetWordDescent(*pWord, true));
                     fWordWidth = m_pVT->GetWordWidth(*pWord);
                 } else {
                     fLineAscent = FPDF_MAX(fLineAscent, m_pVT->GetWordAscent(*pWord, fFontSize));
@@ -636,20 +636,20 @@ void CTypeset::SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize)
                 }
                 if (!bOpened) {
                     if (IsOpenStylePunctuation(pWord->Word)) {
-                        bOpened = TRUE;
-                        bFullWord = TRUE;
+                        bOpened = true;
+                        bFullWord = true;
                     } else if (pOldWord != NULL) {
                         if (NeedDivision(pOldWord->Word, pWord->Word)) {
-                            bFullWord = TRUE;
+                            bFullWord = true;
                         }
                     }
                 } else {
                     if (!IsSpace(pWord->Word) && !IsOpenStylePunctuation(pWord->Word)) {
-                        bOpened = FALSE;
+                        bOpened = false;
                     }
                 }
                 if (bFullWord) {
-                    bFullWord = FALSE;
+                    bFullWord = false;
                     if (nCharIndex > 0) {
                         nLineFullWordIndex ++;
                     }
@@ -691,7 +691,7 @@ void CTypeset::SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize)
                 fLineDescent = 0.0f;
                 nCharIndex = 0;
                 nLineFullWordIndex = 0;
-                bFullWord = FALSE;
+                bFullWord = false;
             } else {
                 fLineWidth += fWordWidth;
                 i++;
@@ -809,17 +809,17 @@ void CTypeset::OutputLines()
 CPDF_VariableText::CPDF_VariableText() :
     m_nLimitChar(0),
     m_nCharArray(0),
-    m_bMultiLine(FALSE),
-    m_bLimitWidth(FALSE),
-    m_bAutoFontSize(FALSE),
+    m_bMultiLine(false),
+    m_bLimitWidth(false),
+    m_bAutoFontSize(false),
     m_nAlignment(0),
     m_fLineLeading(0.0f),
     m_fCharSpace(0.0f),
     m_nHorzScale(100),
     m_wSubWord(0),
     m_fFontSize(0.0f),
-    m_bInitial(FALSE),
-    m_bRichText(FALSE),
+    m_bInitial(false),
+    m_bRichText(false),
     m_pVTProvider(NULL),
     m_pVTIterator(NULL)
 {
@@ -848,12 +848,12 @@ void CPDF_VariableText::Initialize()
         if (CSection * pSection = m_SectionArray.GetAt(0)) {
             pSection->ResetLinePlace();
         }
-        m_bInitial = TRUE;
+        m_bInitial = true;
     }
 }
 void CPDF_VariableText::ResetAll()
 {
-    m_bInitial = FALSE;
+    m_bInitial = false;
     ResetSectionArray();
 }
 CPVT_WordPlace CPDF_VariableText::InsertWord(const CPVT_WordPlace & place, FX_WORD word, int32_t charset,
@@ -956,7 +956,7 @@ CPVT_WordPlace CPDF_VariableText::InsertText(const CPVT_WordPlace & place, const
 }
 CPVT_WordPlace CPDF_VariableText::DeleteWords(const CPVT_WordRange & PlaceRange)
 {
-    FX_BOOL bLastSecPos = FALSE;
+    bool bLastSecPos = false;
     if (CSection * pSection = m_SectionArray.GetAt(PlaceRange.EndPos.nSecIndex)) {
         bLastSecPos = (PlaceRange.EndPos == pSection->GetEndWordPlace());
     }
@@ -971,11 +971,11 @@ CPVT_WordPlace CPDF_VariableText::DeleteWords(const CPVT_WordRange & PlaceRange)
 }
 CPVT_WordPlace CPDF_VariableText::DeleteWord(const CPVT_WordPlace & place)
 {
-    return ClearRightWord(AjustLineHeader(place, TRUE));
+    return ClearRightWord(AjustLineHeader(place, true));
 }
 CPVT_WordPlace CPDF_VariableText::BackSpaceWord(const CPVT_WordPlace & place)
 {
-    return ClearLeftWord(AjustLineHeader(place, TRUE));
+    return ClearLeftWord(AjustLineHeader(place, true));
 }
 void CPDF_VariableText::SetText(const FX_WCHAR* text, int32_t charset, const CPVT_SecProps * pSecProps,
                                 const CPVT_WordProps * pWordProps)
@@ -1044,7 +1044,7 @@ void CPDF_VariableText::UpdateWordPlace(CPVT_WordPlace & place) const
     if (place.nSecIndex >= m_SectionArray.GetSize()) {
         place = GetEndWordPlace();
     }
-    place = AjustLineHeader(place, TRUE);
+    place = AjustLineHeader(place, true);
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         pSection->UpdateWordPlace(place);
     }
@@ -1073,19 +1073,19 @@ CPVT_WordPlace CPDF_VariableText::WordIndexToWordPlace(int32_t index) const
 {
     CPVT_WordPlace place = GetBeginWordPlace();
     int32_t nOldIndex = 0 , nIndex = 0;
-    FX_BOOL bFind = FALSE;
+    bool bFind = false;
     for (int32_t i = 0, sz = m_SectionArray.GetSize(); i < sz; i++) {
         if (CSection * pSection = m_SectionArray.GetAt(i)) {
             nIndex += pSection->m_WordArray.GetSize();
             if (nIndex == index) {
                 place = pSection->GetEndWordPlace();
-                bFind = TRUE;
+                bFind = true;
                 break;
             } else if (nIndex > index) {
                 place.nSecIndex = i;
                 place.nWordIndex = index - nOldIndex - 1;
                 pSection->UpdateWordPlace(place);
-                bFind = TRUE;
+                bFind = true;
                 break;
             }
             if (i != m_SectionArray.GetSize() - 1) {
@@ -1155,15 +1155,15 @@ CPVT_WordPlace CPDF_VariableText::SearchWordPlace(const CPDF_Point & point) cons
     int32_t nLeft = 0;
     int32_t nRight = m_SectionArray.GetSize() - 1;
     int32_t nMid = m_SectionArray.GetSize() / 2;
-    FX_BOOL bUp = TRUE;
-    FX_BOOL bDown = TRUE;
+    bool bUp = true;
+    bool bDown = true;
     while (nLeft <= nRight) {
         if (CSection * pSection = m_SectionArray.GetAt(nMid)) {
             if (IsFloatBigger(pt.y, pSection->m_SecInfo.rcSection.top)) {
-                bUp = FALSE;
+                bUp = false;
             }
             if (IsFloatBigger(pSection->m_SecInfo.rcSection.bottom, pt.y)) {
-                bDown = FALSE;
+                bDown = false;
             }
             if (IsFloatSmaller(pt.y, pSection->m_SecInfo.rcSection.top)) {
                 nRight = nMid - 1;
@@ -1303,49 +1303,49 @@ CPVT_WordPlace CPDF_VariableText::AddWord(const CPVT_WordPlace & place, const CP
     }
     return place;
 }
-FX_BOOL CPDF_VariableText::GetWordInfo(const CPVT_WordPlace & place, CPVT_WordInfo & wordinfo)
+bool CPDF_VariableText::GetWordInfo(const CPVT_WordPlace & place, CPVT_WordInfo & wordinfo)
 {
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         if (CPVT_WordInfo * pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
             wordinfo = *pWord;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_VariableText::SetWordInfo(const CPVT_WordPlace & place, const CPVT_WordInfo & wordinfo)
+bool CPDF_VariableText::SetWordInfo(const CPVT_WordPlace & place, const CPVT_WordInfo & wordinfo)
 {
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         if (CPVT_WordInfo * pWord = pSection->m_WordArray.GetAt(place.nWordIndex)) {
             *pWord = wordinfo;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_VariableText::GetLineInfo(const CPVT_WordPlace & place, CPVT_LineInfo & lineinfo)
+bool CPDF_VariableText::GetLineInfo(const CPVT_WordPlace & place, CPVT_LineInfo & lineinfo)
 {
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         if (CLine * pLine = pSection->m_LineArray.GetAt(place.nLineIndex)) {
             lineinfo = pLine->m_LineInfo;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_VariableText::GetSectionInfo(const CPVT_WordPlace & place, CPVT_SectionInfo & secinfo)
+bool CPDF_VariableText::GetSectionInfo(const CPVT_WordPlace & place, CPVT_SectionInfo & secinfo)
 {
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         secinfo = pSection->m_SecInfo;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 CPDF_Rect CPDF_VariableText::GetContentRect() const
 {
     return InToOut(CPDF_EditContainer::GetContentRect());
 }
-FX_FLOAT CPDF_VariableText::GetWordFontSize(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize)
+FX_FLOAT CPDF_VariableText::GetWordFontSize(const CPVT_WordInfo & WordInfo, bool bFactFontSize)
 {
     return m_bRichText && WordInfo.pWordProps ? (WordInfo.pWordProps->nScriptType == PVTWORD_SCRIPT_NORMAL || bFactFontSize ? WordInfo.pWordProps->fFontSize : WordInfo.pWordProps->fFontSize * PVT_HALF) : GetFontSize();
 }
@@ -1391,11 +1391,11 @@ FX_FLOAT CPDF_VariableText::GetWordDescent(const CPVT_WordInfo & WordInfo, FX_FL
 {
     return GetFontDescent(GetWordFontIndex(WordInfo), fFontSize);
 }
-FX_FLOAT CPDF_VariableText::GetWordAscent(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize)
+FX_FLOAT CPDF_VariableText::GetWordAscent(const CPVT_WordInfo & WordInfo, bool bFactFontSize)
 {
     return GetFontAscent(GetWordFontIndex(WordInfo), GetWordFontSize(WordInfo, bFactFontSize));
 }
-FX_FLOAT CPDF_VariableText::GetWordDescent(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize)
+FX_FLOAT CPDF_VariableText::GetWordDescent(const CPVT_WordInfo & WordInfo, bool bFactFontSize)
 {
     return GetFontDescent(GetWordFontIndex(WordInfo), GetWordFontSize(WordInfo, bFactFontSize));
 }
@@ -1421,7 +1421,7 @@ int32_t CPDF_VariableText::GetHorzScale(const CPVT_WordInfo & WordInfo)
 }
 void CPDF_VariableText::ClearSectionRightWords(const CPVT_WordPlace & place)
 {
-    CPVT_WordPlace wordplace = AjustLineHeader(place, TRUE);
+    CPVT_WordPlace wordplace = AjustLineHeader(place, true);
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         for (int32_t w = pSection->m_WordArray.GetSize() - 1; w > wordplace.nWordIndex; w--) {
             delete pSection->m_WordArray.GetAt(w);
@@ -1429,26 +1429,26 @@ void CPDF_VariableText::ClearSectionRightWords(const CPVT_WordPlace & place)
         }
     }
 }
-CPVT_WordPlace CPDF_VariableText::AjustLineHeader(const CPVT_WordPlace & place, FX_BOOL bPrevOrNext) const
+CPVT_WordPlace CPDF_VariableText::AjustLineHeader(const CPVT_WordPlace & place, bool bPrevOrNext) const
 {
     if (place.nWordIndex < 0 && place.nLineIndex > 0) {
         return bPrevOrNext ? GetPrevWordPlace(place) : GetNextWordPlace(place);
     }
     return place;
 }
-FX_BOOL CPDF_VariableText::ClearEmptySection(const CPVT_WordPlace & place)
+bool CPDF_VariableText::ClearEmptySection(const CPVT_WordPlace & place)
 {
     if (place.nSecIndex == 0 && m_SectionArray.GetSize() == 1) {
-        return FALSE;
+        return false;
     }
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
         if (pSection->m_WordArray.GetSize() == 0) {
             delete pSection;
             m_SectionArray.RemoveAt(place.nSecIndex);
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 void CPDF_VariableText::ClearEmptySections(const CPVT_WordRange & PlaceRange)
 {
@@ -1460,7 +1460,7 @@ void CPDF_VariableText::ClearEmptySections(const CPVT_WordRange & PlaceRange)
 }
 void CPDF_VariableText::LinkLatterSection(const CPVT_WordPlace & place)
 {
-    CPVT_WordPlace oldplace = AjustLineHeader(place, TRUE);
+    CPVT_WordPlace oldplace = AjustLineHeader(place, true);
     if (CSection * pNextSection = m_SectionArray.GetAt(place.nSecIndex + 1)) {
         if (CSection * pSection = m_SectionArray.GetAt(oldplace.nSecIndex)) {
             for (int32_t w = 0, sz = pNextSection->m_WordArray.GetSize(); w < sz; w++) {
@@ -1477,8 +1477,8 @@ void CPDF_VariableText::LinkLatterSection(const CPVT_WordPlace & place)
 void CPDF_VariableText::ClearWords(const CPVT_WordRange & PlaceRange)
 {
     CPVT_WordRange NewRange;
-    NewRange.BeginPos = AjustLineHeader(PlaceRange.BeginPos, TRUE);
-    NewRange.EndPos = AjustLineHeader(PlaceRange.EndPos, TRUE);
+    NewRange.BeginPos = AjustLineHeader(PlaceRange.BeginPos, true);
+    NewRange.EndPos = AjustLineHeader(PlaceRange.EndPos, true);
     for (int32_t s = NewRange.EndPos.nSecIndex; s >= NewRange.BeginPos.nSecIndex; s--) {
         if (CSection * pSection = m_SectionArray.GetAt(s)) {
             pSection->ClearWords(NewRange);
@@ -1507,7 +1507,7 @@ CPVT_WordPlace CPDF_VariableText::ClearLeftWord(const CPVT_WordPlace & place)
 CPVT_WordPlace CPDF_VariableText::ClearRightWord(const CPVT_WordPlace & place)
 {
     if (CSection * pSection = m_SectionArray.GetAt(place.nSecIndex)) {
-        CPVT_WordPlace rightplace = AjustLineHeader(GetNextWordPlace(place), FALSE);
+        CPVT_WordPlace rightplace = AjustLineHeader(GetNextWordPlace(place), false);
         if (rightplace != place) {
             if(rightplace.nSecIndex != place.nSecIndex) {
                 LinkLatterSection(place);
@@ -1568,9 +1568,9 @@ FX_FLOAT CPDF_VariableText::GetAutoFontSize()
     }
     return (FX_FLOAT)gFontSizeSteps[nMid];
 }
-FX_BOOL	CPDF_VariableText::IsBigger(FX_FLOAT fFontSize)
+bool	CPDF_VariableText::IsBigger(FX_FLOAT fFontSize)
 {
-    FX_BOOL bBigger =  FALSE;
+    bool bBigger =  false;
     CPVT_Size szTotal;
     for (int32_t s = 0, sz = m_SectionArray.GetSize(); s < sz; s++) {
         if (CSection * pSection = m_SectionArray.GetAt(s)) {
@@ -1580,7 +1580,7 @@ FX_BOOL	CPDF_VariableText::IsBigger(FX_FLOAT fFontSize)
             if (IsFloatBigger(szTotal.x, GetPlateWidth())
                     || IsFloatBigger(szTotal.y, GetPlateHeight())
                ) {
-                bBigger = TRUE;
+                bBigger = true;
                 break;
             }
         }
@@ -1652,9 +1652,9 @@ int32_t CPDF_VariableText::GetDefaultFontIndex()
 {
     return m_pVTProvider ? m_pVTProvider->GetDefaultFontIndex() : -1;
 }
-FX_BOOL	CPDF_VariableText::IsLatinWord(FX_WORD word)
+bool	CPDF_VariableText::IsLatinWord(FX_WORD word)
 {
-    return m_pVTProvider ? m_pVTProvider->IsLatinWord(word) : FALSE;
+    return m_pVTProvider ? m_pVTProvider->IsLatinWord(word) : false;
 }
 IPDF_VariableText_Iterator * CPDF_VariableText::GetIterator()
 {
@@ -1687,70 +1687,70 @@ void CPDF_VariableText_Iterator::SetAt(const CPVT_WordPlace & place)
     ASSERT(m_pVT != NULL);
     m_CurPos = place;
 }
-FX_BOOL	CPDF_VariableText_Iterator::NextWord()
+bool	CPDF_VariableText_Iterator::NextWord()
 {
     if (m_CurPos == m_pVT->GetEndWordPlace()) {
-        return FALSE;
+        return false;
     }
     m_CurPos = m_pVT->GetNextWordPlace(m_CurPos);
-    return TRUE;
+    return true;
 }
-FX_BOOL	CPDF_VariableText_Iterator::PrevWord()
+bool	CPDF_VariableText_Iterator::PrevWord()
 {
     if (m_CurPos == m_pVT->GetBeginWordPlace()) {
-        return FALSE;
+        return false;
     }
     m_CurPos = m_pVT->GetPrevWordPlace(m_CurPos);
-    return TRUE;
+    return true;
 }
-FX_BOOL	CPDF_VariableText_Iterator::NextLine()
+bool	CPDF_VariableText_Iterator::NextLine()
 {
     if (CSection * pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
         if (m_CurPos.nLineIndex < pSection->m_LineArray.GetSize() - 1) {
             m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex + 1, -1);
-            return TRUE;
+            return true;
         }
         if (m_CurPos.nSecIndex < m_pVT->m_SectionArray.GetSize() - 1) {
             m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex + 1, 0, -1);
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::PrevLine()
+bool	CPDF_VariableText_Iterator::PrevLine()
 {
     if (m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
         if (m_CurPos.nLineIndex > 0) {
             m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex - 1, -1);
-            return TRUE;
+            return true;
         }
         if (m_CurPos.nSecIndex > 0) {
             if (CSection * pLastSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex - 1)) {
                 m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex - 1, pLastSection->m_LineArray.GetSize() - 1, -1);
-                return TRUE;
+                return true;
             }
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::NextSection()
+bool	CPDF_VariableText_Iterator::NextSection()
 {
     if (m_CurPos.nSecIndex < m_pVT->m_SectionArray.GetSize() - 1) {
         m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex + 1, 0, -1);
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::PrevSection()
+bool	CPDF_VariableText_Iterator::PrevSection()
 {
     ASSERT(m_pVT != NULL);
     if (m_CurPos.nSecIndex > 0) {
         m_CurPos = CPVT_WordPlace(m_CurPos.nSecIndex - 1, 0, -1);
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::GetWord(CPVT_Word & word) const
+bool	CPDF_VariableText_Iterator::GetWord(CPVT_Word & word) const
 {
     ASSERT(m_pVT != NULL);
     word.WordPlace = m_CurPos;
@@ -1770,13 +1770,13 @@ FX_BOOL	CPDF_VariableText_Iterator::GetWord(CPVT_Word & word) const
                 }
                 word.nFontIndex = m_pVT->GetWordFontIndex(*pWord);
                 word.fFontSize = m_pVT->GetWordFontSize(*pWord);
-                return TRUE;
+                return true;
             }
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::SetWord(const CPVT_Word & word)
+bool	CPDF_VariableText_Iterator::SetWord(const CPVT_Word & word)
 {
     ASSERT(m_pVT != NULL);
     if (CSection * pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
@@ -1784,12 +1784,12 @@ FX_BOOL	CPDF_VariableText_Iterator::SetWord(const CPVT_Word & word)
             if (pWord->pWordProps) {
                 *pWord->pWordProps = word.WordProps;
             }
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::GetLine(CPVT_Line & line) const
+bool	CPDF_VariableText_Iterator::GetLine(CPVT_Line & line) const
 {
     ASSERT(m_pVT != NULL);
     line.lineplace = CPVT_WordPlace(m_CurPos.nSecIndex, m_CurPos.nLineIndex, -1);
@@ -1802,12 +1802,12 @@ FX_BOOL	CPDF_VariableText_Iterator::GetLine(CPVT_Line & line) const
             line.fLineAscent = pLine->m_LineInfo.fLineAscent;
             line.fLineDescent = pLine->m_LineInfo.fLineDescent;
             line.lineEnd = pLine->GetEndWordPlace();
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::GetSection(CPVT_Section & section) const
+bool	CPDF_VariableText_Iterator::GetSection(CPVT_Section & section) const
 {
     ASSERT(m_pVT != NULL);
     section.secplace = CPVT_WordPlace(m_CurPos.nSecIndex, 0, -1);
@@ -1819,11 +1819,11 @@ FX_BOOL	CPDF_VariableText_Iterator::GetSection(CPVT_Section & section) const
         if (pSection->m_SecInfo.pWordProps) {
             section.WordProps = *pSection->m_SecInfo.pWordProps;
         }
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CPDF_VariableText_Iterator::SetSection(const CPVT_Section & section)
+bool	CPDF_VariableText_Iterator::SetSection(const CPVT_Section & section)
 {
     ASSERT(m_pVT != NULL);
     if (CSection * pSection = m_pVT->m_SectionArray.GetAt(m_CurPos.nSecIndex)) {
@@ -1833,7 +1833,7 @@ FX_BOOL	CPDF_VariableText_Iterator::SetSection(const CPVT_Section & section)
         if (pSection->m_SecInfo.pWordProps) {
             *pSection->m_SecInfo.pWordProps = section.WordProps;
         }
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
diff --git a/core/src/fpdfdoc/pdf_vt.h b/core/src/fpdfdoc/pdf_vt.h
index a75490fcd5..fb7910bff5 100644
--- a/core/src/fpdfdoc/pdf_vt.h
+++ b/core/src/fpdfdoc/pdf_vt.h
@@ -191,7 +191,7 @@ struct CPVT_FloatRange {
 template<class TYPE> class CPVT_ArrayTemplate : public CFX_ArrayTemplate<TYPE>
 {
 public:
-    FX_BOOL IsEmpty()
+    bool IsEmpty()
     {
         return CFX_ArrayTemplate<TYPE>::GetSize() <= 0;
     }
@@ -316,7 +316,7 @@ public:
     CPVT_FloatRect							Typeset();
     CPVT_FloatRect							CharArray();
 private:
-    void									SplitLines(FX_BOOL bTypeset, FX_FLOAT fFontSize);
+    void									SplitLines(bool bTypeset, FX_FLOAT fFontSize);
     void									OutputLines();
 
     CPVT_FloatRect							m_rcRet;
@@ -423,11 +423,11 @@ public:
     {
         m_nHorzScale = nHorzScale;
     }
-    void									SetMultiLine(FX_BOOL bMultiLine = TRUE)
+    void									SetMultiLine(bool bMultiLine = true)
     {
         m_bMultiLine = bMultiLine;
     }
-    void									SetAutoReturn(FX_BOOL bAuto = TRUE)
+    void									SetAutoReturn(bool bAuto = true)
     {
         m_bLimitWidth = bAuto;
     }
@@ -439,11 +439,11 @@ public:
     {
         m_nCharArray = nCharArray;
     }
-    void									SetAutoFontSize(FX_BOOL bAuto = TRUE)
+    void									SetAutoFontSize(bool bAuto = true)
     {
         m_bAutoFontSize = bAuto;
     }
-    void									SetRichText(FX_BOOL bRichText)
+    void									SetRichText(bool bRichText)
     {
         m_bRichText = bRichText;
     }
@@ -452,11 +452,11 @@ public:
         m_fLineLeading = fLineLeading;
     }
     void									Initialize();
-    FX_BOOL									IsValid() const
+    bool									IsValid() const
     {
         return m_bInitial;
     }
-    FX_BOOL									IsRichText() const
+    bool									IsRichText() const
     {
         return m_bRichText;
     }
@@ -496,7 +496,7 @@ public:
     {
         return m_nLimitChar;
     }
-    FX_BOOL									IsMultiLine() const
+    bool									IsMultiLine() const
     {
         return m_bMultiLine;
     }
@@ -537,25 +537,25 @@ private:
     int32_t								GetTypeDescent(int32_t nFontIndex);
     int32_t								GetWordFontIndex(FX_WORD word, int32_t charset, int32_t nFontIndex);
     int32_t								GetDefaultFontIndex();
-    FX_BOOL									IsLatinWord(FX_WORD word);
+    bool									IsLatinWord(FX_WORD word);
 private:
 
     CPVT_WordPlace							AddSection(const CPVT_WordPlace & place, const CPVT_SectionInfo & secinfo);
     CPVT_WordPlace							AddLine(const CPVT_WordPlace & place, const CPVT_LineInfo & lineinfo);
     CPVT_WordPlace							AddWord(const CPVT_WordPlace & place, const CPVT_WordInfo & wordinfo);
-    FX_BOOL									GetWordInfo(const CPVT_WordPlace & place, CPVT_WordInfo & wordinfo);
-    FX_BOOL									SetWordInfo(const CPVT_WordPlace & place, const CPVT_WordInfo & wordinfo);
-    FX_BOOL									GetLineInfo(const CPVT_WordPlace & place, CPVT_LineInfo & lineinfo);
-    FX_BOOL									GetSectionInfo(const CPVT_WordPlace & place, CPVT_SectionInfo & secinfo);
-    FX_FLOAT								GetWordFontSize(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize = FALSE);
+    bool									GetWordInfo(const CPVT_WordPlace & place, CPVT_WordInfo & wordinfo);
+    bool									SetWordInfo(const CPVT_WordPlace & place, const CPVT_WordInfo & wordinfo);
+    bool									GetLineInfo(const CPVT_WordPlace & place, CPVT_LineInfo & lineinfo);
+    bool									GetSectionInfo(const CPVT_WordPlace & place, CPVT_SectionInfo & secinfo);
+    FX_FLOAT								GetWordFontSize(const CPVT_WordInfo & WordInfo, bool bFactFontSize = false);
     FX_FLOAT								GetWordWidth(int32_t nFontIndex, FX_WORD Word, FX_WORD SubWord,
             FX_FLOAT fCharSpace, int32_t nHorzScale,
             FX_FLOAT fFontSize, FX_FLOAT fWordTail, int32_t nWordStyle);
     FX_FLOAT								GetWordWidth(const CPVT_WordInfo & WordInfo);
     FX_FLOAT								GetWordAscent(const CPVT_WordInfo & WordInfo, FX_FLOAT fFontSize);
     FX_FLOAT								GetWordDescent(const CPVT_WordInfo & WordInfo, FX_FLOAT fFontSize);
-    FX_FLOAT								GetWordAscent(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize = FALSE);
-    FX_FLOAT								GetWordDescent(const CPVT_WordInfo & WordInfo, FX_BOOL bFactFontSize = FALSE);
+    FX_FLOAT								GetWordAscent(const CPVT_WordInfo & WordInfo, bool bFactFontSize = false);
+    FX_FLOAT								GetWordDescent(const CPVT_WordInfo & WordInfo, bool bFactFontSize = false);
     FX_FLOAT								GetLineAscent(const CPVT_SectionInfo & SecInfo);
     FX_FLOAT								GetLineDescent(const CPVT_SectionInfo & SecInfo);
     FX_FLOAT								GetFontAscent(int32_t nFontIndex, FX_FLOAT fFontSize);
@@ -568,8 +568,8 @@ private:
     int32_t								GetAlignment(const CPVT_SectionInfo& SecInfo);
 
     void									ClearSectionRightWords(const CPVT_WordPlace & place);
-    CPVT_WordPlace							AjustLineHeader(const CPVT_WordPlace & place, FX_BOOL bPrevOrNext) const;
-    FX_BOOL									ClearEmptySection(const CPVT_WordPlace & place);
+    CPVT_WordPlace							AjustLineHeader(const CPVT_WordPlace & place, bool bPrevOrNext) const;
+    bool									ClearEmptySection(const CPVT_WordPlace & place);
     void									ClearEmptySections(const CPVT_WordRange & PlaceRange);
     void									LinkLatterSection(const CPVT_WordPlace & place);
     void									ClearWords(const CPVT_WordRange & PlaceRange);
@@ -578,7 +578,7 @@ private:
 private:
     CPVT_FloatRect							Rearrange(const CPVT_WordRange & PlaceRange);
     FX_FLOAT								GetAutoFontSize();
-    FX_BOOL									IsBigger(FX_FLOAT fFontSize);
+    bool									IsBigger(FX_FLOAT fFontSize);
     CPVT_FloatRect							RearrangeSections(const CPVT_WordRange & PlaceRange);
 private:
     void									ResetSectionArray();
@@ -586,9 +586,9 @@ private:
     CPVT_ArrayTemplate<CSection*>			m_SectionArray;
     int32_t								m_nLimitChar;
     int32_t								m_nCharArray;
-    FX_BOOL									m_bMultiLine;
-    FX_BOOL									m_bLimitWidth;
-    FX_BOOL									m_bAutoFontSize;
+    bool									m_bMultiLine;
+    bool									m_bLimitWidth;
+    bool									m_bAutoFontSize;
     int32_t								m_nAlignment;
     FX_FLOAT								m_fLineLeading;
     FX_FLOAT								m_fCharSpace;
@@ -597,8 +597,8 @@ private:
     FX_FLOAT								m_fFontSize;
 
 private:
-    FX_BOOL									m_bInitial;
-    FX_BOOL									m_bRichText;
+    bool									m_bInitial;
+    bool									m_bRichText;
     IPDF_VariableText_Provider *			m_pVTProvider;
     CPDF_VariableText_Iterator *			m_pVTIterator;
 };
@@ -607,17 +607,17 @@ class CPDF_VariableText_Iterator : public IPDF_VariableText_Iterator
 public:
     CPDF_VariableText_Iterator(CPDF_VariableText * pVT);
     virtual ~CPDF_VariableText_Iterator();
-    FX_BOOL									NextWord();
-    FX_BOOL									PrevWord();
-    FX_BOOL									NextLine();
-    FX_BOOL									PrevLine();
-    FX_BOOL									NextSection();
-    FX_BOOL									PrevSection();
-    FX_BOOL									SetWord(const CPVT_Word & word);
-    FX_BOOL									GetWord(CPVT_Word & word) const;
-    FX_BOOL									GetLine(CPVT_Line & line) const;
-    FX_BOOL									GetSection(CPVT_Section & section) const;
-    FX_BOOL									SetSection(const CPVT_Section & section);
+    bool									NextWord();
+    bool									PrevWord();
+    bool									NextLine();
+    bool									PrevLine();
+    bool									NextSection();
+    bool									PrevSection();
+    bool									SetWord(const CPVT_Word & word);
+    bool									GetWord(CPVT_Word & word) const;
+    bool									GetLine(CPVT_Line & line) const;
+    bool									GetSection(CPVT_Section & section) const;
+    bool									SetSection(const CPVT_Section & section);
     void									SetAt(int32_t nWordIndex);
     void									SetAt(const CPVT_WordPlace & place);
     const CPVT_WordPlace &					GetAt() const
diff --git a/core/src/fpdfdoc/tagged_int.h b/core/src/fpdfdoc/tagged_int.h
index 9c643a6d6b..1279617681 100644
--- a/core/src/fpdfdoc/tagged_int.h
+++ b/core/src/fpdfdoc/tagged_int.h
@@ -26,7 +26,7 @@ public:
     void		LoadDocTree();
     void		LoadPageTree(const CPDF_Dictionary* pPageDict);
     CPDF_StructElementImpl* AddPageNode(CPDF_Dictionary* pElement, CFX_MapPtrToPtr& map, int nLevel = 0);
-    FX_BOOL		AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_StructElementImpl* pElement);
+    bool		AddTopLevelNode(CPDF_Dictionary* pDict, CPDF_StructElementImpl* pElement);
 protected:
     const CPDF_Dictionary*	m_pTreeRoot;
     const CPDF_Dictionary*	m_pRoleMap;
@@ -67,16 +67,16 @@ public:
         return &m_ObjectArray;
     }
 
-    CPDF_Object*			GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_BOOL bInheritable = FALSE, FX_FLOAT fLevel = 0.0F);
+    CPDF_Object*			GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, bool bInheritable = false, FX_FLOAT fLevel = 0.0F);
 
-    CFX_ByteString			GetName(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, const CFX_ByteStringC& default_value, FX_BOOL bInheritable = FALSE, int subindex = -1);
-    FX_ARGB					GetColor(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_ARGB default_value, FX_BOOL bInheritable = FALSE, int subindex = -1);
-    FX_FLOAT				GetNumber(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_FLOAT default_value, FX_BOOL bInheritable = FALSE, int subindex = -1);
-    int						GetInteger(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, int default_value, FX_BOOL bInheritable = FALSE, int subindex = -1);
+    CFX_ByteString			GetName(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, const CFX_ByteStringC& default_value, bool bInheritable = false, int subindex = -1);
+    FX_ARGB					GetColor(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_ARGB default_value, bool bInheritable = false, int subindex = -1);
+    FX_FLOAT				GetNumber(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_FLOAT default_value, bool bInheritable = false, int subindex = -1);
+    int						GetInteger(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, int default_value, bool bInheritable = false, int subindex = -1);
     CFX_PtrArray			m_ObjectArray;
     void					LoadKids(CPDF_Dictionary* pDict);
     void					LoadKid(FX_DWORD PageObjNum, CPDF_Object* pObj, CPDF_StructKid* pKid);
-    CPDF_Object*			GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, FX_BOOL bInheritable, int subindex);
+    CPDF_Object*			GetAttr(const CFX_ByteStringC& owner, const CFX_ByteStringC& name, bool bInheritable, int subindex);
     CPDF_StructElementImpl*	Retain();
     void					Release();
 protected:
diff --git a/core/src/fpdftext/fpdf_text.cpp b/core/src/fpdftext/fpdf_text.cpp
index 7203a694ab..7d728a8ae7 100644
--- a/core/src/fpdftext/fpdf_text.cpp
+++ b/core/src/fpdftext/fpdf_text.cpp
@@ -289,7 +289,7 @@ void CTextPage::WriteOutput(CFX_WideStringArray& lines, int iMinWidth)
 }
 void NormalizeCompositeChar(FX_WCHAR wChar, CFX_WideString& sDest)
 {
-    wChar = FX_GetMirrorChar(wChar, TRUE, FALSE);
+    wChar = FX_GetMirrorChar(wChar, true, false);
     FX_WCHAR* pDst = NULL;
     FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
     if (nCount < 1 ) {
@@ -311,7 +311,7 @@ void NormalizeString(CFX_WideString& str)
     CFX_WideString sBuffer;
     nonstd::unique_ptr<IFX_BidiChar> pBidiChar(IFX_BidiChar::Create());
     CFX_WordArray order;
-    FX_BOOL bR2L = FALSE;
+    bool bR2L = false;
     int32_t start = 0, count = 0, i = 0;
     int nR2L = 0, nL2R = 0;
     for (i = 0; i < str.GetLength(); i++) {
@@ -343,7 +343,7 @@ void NormalizeString(CFX_WideString& str)
         }
     }
     if(nR2L > 0 && nR2L >= nL2R) {
-        bR2L = TRUE;
+        bR2L = true;
     }
     if(bR2L) {
         int count = order.GetSize();
@@ -357,7 +357,7 @@ void NormalizeString(CFX_WideString& str)
                 }
             } else {
                 i = j;
-                FX_BOOL bSymbol = FALSE;
+                bool bSymbol = false;
                 while(i > 0 && order.GetAt(i) != 2) {
                     bSymbol = !order.GetAt(i);
                     i -= 3;
@@ -389,7 +389,7 @@ void NormalizeString(CFX_WideString& str)
         }
     } else {
         int count = order.GetSize();
-        FX_BOOL bL2R = FALSE;
+        bool bL2R = false;
         for(int j = 0; j < count; j += 3) {
             int ret = order.GetAt(j + 2);
             int start = order.GetAt(j);
@@ -405,7 +405,7 @@ void NormalizeString(CFX_WideString& str)
                 }
                 if(i == 3) {
                     j = -3;
-                    bL2R = TRUE;
+                    bL2R = true;
                     continue;
                 }
                 int end = str.GetLength() - 1;
@@ -427,15 +427,15 @@ void NormalizeString(CFX_WideString& str)
     str.Empty();
     str += sBuffer;
 }
-static FX_BOOL IsNumber(CFX_WideString& str)
+static bool IsNumber(CFX_WideString& str)
 {
     for (int i = 0; i < str.GetLength(); i ++) {
         FX_WCHAR ch = str[i];
         if ((ch < '0' || ch > '9') && ch != '-' && ch != '+' && ch != '.' && ch != ' ') {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 void CTextPage::FindColumns()
 {
@@ -534,18 +534,18 @@ void CTextBaseLine::InsertTextBox(FX_FLOAT leftx, FX_FLOAT rightx, FX_FLOAT topy
     pText->m_pColumn = NULL;
     m_TextList.InsertAt(i, pText);
 }
-FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
+bool GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
                         FX_FLOAT& interlow, FX_FLOAT& interhigh);
-FX_BOOL CTextBaseLine::CanMerge(CTextBaseLine* pOther)
+bool CTextBaseLine::CanMerge(CTextBaseLine* pOther)
 {
     FX_FLOAT inter_top, inter_bottom;
     if (!GetIntersection(m_Bottom, m_Top, pOther->m_Bottom, pOther->m_Top,
                          inter_bottom, inter_top)) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT inter_h = inter_top - inter_bottom;
     if (inter_h < (m_Top - m_Bottom) / 2 && inter_h < (pOther->m_Top - pOther->m_Bottom) / 2) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT dy = (FX_FLOAT)FXSYS_fabs(m_BaseLine - pOther->m_BaseLine);
     for (int i = 0; i < m_TextList.GetSize(); i ++) {
@@ -563,11 +563,11 @@ FX_BOOL CTextBaseLine::CanMerge(CTextBaseLine* pOther)
             }
             if (dy >= (pText->m_Bottom - pText->m_Top) / 2 ||
                     dy >= (pOtherText->m_Bottom - pOtherText->m_Top) / 2) {
-                return FALSE;
+                return false;
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CTextBaseLine::Merge(CTextBaseLine* pOther)
 {
@@ -577,7 +577,7 @@ void CTextBaseLine::Merge(CTextBaseLine* pOther)
                       pText->m_SpaceWidth, pText->m_FontSizeV, pText->m_Text);
     }
 }
-FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
+bool CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
 {
     int i;
     for (i = 0; i < m_TextList.GetSize(); i ++) {
@@ -587,7 +587,7 @@ FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
         }
     }
     if (i == m_TextList.GetSize()) {
-        return FALSE;
+        return false;
     }
     CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
     leftx = pText->m_Left;
@@ -599,7 +599,7 @@ FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
     }
     pText = (CTextBox*)m_TextList.GetAt(i);
     rightx = pText->m_Right;
-    return TRUE;
+    return true;
 }
 void CTextBaseLine::MergeBoxes()
 {
@@ -724,8 +724,8 @@ void PDF_GetPageText_Unicode(CFX_WideStringArray& lines, CPDF_Document* pDoc, CP
     CPDF_Page page;
     page.Load(pDoc, pPage);
     CPDF_ParseOptions options;
-    options.m_bTextOnly = TRUE;
-    options.m_bSeparateForm = FALSE;
+    options.m_bTextOnly = true;
+    options.m_bSeparateForm = false;
     page.ParseContent(&options);
     CFX_FloatRect page_bbox = page.GetPageBBox();
     if (flags & PDF2TXT_AUTO_ROTATE) {
@@ -734,7 +734,7 @@ void PDF_GetPageText_Unicode(CFX_WideStringArray& lines, CPDF_Document* pDoc, CP
     CTextPage texts;
     texts.m_bAutoWidth = flags & PDF2TXT_AUTO_WIDTH;
     texts.m_bKeepColumn = flags & PDF2TXT_KEEP_COLUMN;
-    texts.m_bBreakSpace = TRUE;
+    texts.m_bBreakSpace = true;
     FX_POSITION pos = page.GetFirstObjectPosition();
     while (pos) {
         CPDF_PageObject* pObject = page.GetNextObject(pos);
@@ -763,7 +763,7 @@ void PDF_GetPageText(CFX_ByteStringArray& lines, CPDF_Document* pDoc, CPDF_Dicti
         lines.Add(str);
     }
 }
-extern void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, FX_BOOL bUseLF,
+extern void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, bool bUseLF,
                                        CFX_PtrArray* pObjArray);
 void PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_Document* pDoc, CPDF_Dictionary* pPage, FX_DWORD flags)
 {
@@ -771,8 +771,8 @@ void PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_Document* pDoc, CPD
     CPDF_Page page;
     page.Load(pDoc, pPage);
     CPDF_ParseOptions options;
-    options.m_bTextOnly = TRUE;
-    options.m_bSeparateForm = FALSE;
+    options.m_bTextOnly = true;
+    options.m_bSeparateForm = false;
     page.ParseContent(&options);
-    _PDF_GetTextStream_Unicode(buffer, &page, TRUE, NULL);
+    _PDF_GetTextStream_Unicode(buffer, &page, true, NULL);
 }
diff --git a/core/src/fpdftext/fpdf_text_int.cpp b/core/src/fpdftext/fpdf_text_int.cpp
index c1aaad8b5c..f777a3d90b 100644
--- a/core/src/fpdftext/fpdf_text_int.cpp
+++ b/core/src/fpdftext/fpdf_text_int.cpp
@@ -19,10 +19,10 @@
 
 namespace {
 
-FX_BOOL _IsIgnoreSpaceCharacter(FX_WCHAR curChar)
+bool _IsIgnoreSpaceCharacter(FX_WCHAR curChar)
 {
     if(curChar < 255 ) {
-        return FALSE;
+        return false;
     }
     if ( (curChar >= 0x0600 && curChar <= 0x06FF)
             || (curChar >= 0xFE70 && curChar <= 0xFEFF)
@@ -33,9 +33,9 @@ FX_BOOL _IsIgnoreSpaceCharacter(FX_WCHAR curChar)
             || (curChar >= 0x2DE0 && curChar <= 0x2DFF)
             || curChar == 8467
             || (curChar >= 0x2000 && curChar <= 0x206F)) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 
 FX_FLOAT _NormalizeThreshold(FX_FLOAT threshold)
@@ -58,7 +58,7 @@ FX_FLOAT _CalculateBaseSpace(const CPDF_TextObject* pTextObj,
     FX_FLOAT baseSpace = 0.0;
     const int nItems = pTextObj->CountItems();
     if (pTextObj->m_TextState.GetObject()->m_CharSpace && nItems >= 3) {
-        FX_BOOL bAllChar = TRUE;
+        bool bAllChar = true;
         FX_FLOAT spacing = matrix.TransformDistance(
             pTextObj->m_TextState.GetObject()->m_CharSpace);
         baseSpace = spacing;
@@ -69,7 +69,7 @@ FX_FLOAT _CalculateBaseSpace(const CPDF_TextObject* pTextObj,
                 FX_FLOAT fontsize_h = pTextObj->m_TextState.GetFontSizeH();
                 FX_FLOAT kerning = -fontsize_h * item.m_OriginX / 1000;
                 baseSpace = std::min(baseSpace, kerning + spacing);
-                bAllChar = FALSE;
+                bAllChar = false;
             }
         }
         if (baseSpace < 0.0 || (nItems == 3 && !bAllChar)) {
@@ -82,7 +82,7 @@ FX_FLOAT _CalculateBaseSpace(const CPDF_TextObject* pTextObj,
 }  // namespace
 
 CPDFText_ParseOptions::CPDFText_ParseOptions()
-    : m_bGetCharCodeOnly(FALSE), m_bNormalizeObjs(TRUE), m_bOutputHyphen(FALSE)
+    : m_bGetCharCodeOnly(false), m_bNormalizeObjs(true), m_bOutputHyphen(false)
 {
 }
 IPDF_TextPage* IPDF_TextPage::CreateTextPage(const CPDF_Page* pPage, CPDFText_ParseOptions ParserOptions)
@@ -120,7 +120,7 @@ CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, int flags)
     : m_charList(512),
       m_TempCharList(50),
       m_pPreTextObj(NULL),
-      m_IsParsered(FALSE),
+      m_IsParsered(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0)
 {
@@ -134,7 +134,7 @@ CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, CPDFText_ParseOptions Parse
     , m_charList(512)
     , m_TempCharList(50)
     , m_pPreTextObj(NULL)
-    , m_IsParsered(FALSE)
+    , m_IsParsered(false)
     , m_TextlineDir(-1)
     , m_CurlineRect(0, 0, 0, 0)
 {
@@ -147,7 +147,7 @@ CPDF_TextPage::CPDF_TextPage(const CPDF_PageObjects* pPage, int flags)
     : m_charList(512),
       m_TempCharList(50),
       m_pPreTextObj(NULL),
-      m_IsParsered(FALSE),
+      m_IsParsered(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0)
 {
@@ -157,7 +157,7 @@ CPDF_TextPage::CPDF_TextPage(const CPDF_PageObjects* pPage, int flags)
     CFX_FloatRect pageRect = pPage->CalcBoundingBox();
     m_DisplayMatrix = CFX_AffineMatrix(1, 0, 0, -1, pageRect.right, pageRect.top);
 }
-void CPDF_TextPage::NormalizeObjects(FX_BOOL bNormalize)
+void CPDF_TextPage::NormalizeObjects(bool bNormalize)
 {
     m_ParseOptions.m_bNormalizeObjs = bNormalize;
 }
@@ -177,18 +177,18 @@ bool CPDF_TextPage::IsControlChar(const PAGECHAR_INFO& charInfo)
             return false;
     }
 }
-FX_BOOL CPDF_TextPage::ParseTextPage()
+bool CPDF_TextPage::ParseTextPage()
 {
     if (!m_pPage) {
-        m_IsParsered = FALSE;
-        return FALSE;
+        m_IsParsered = false;
+        return false;
     }
-    m_IsParsered = FALSE;
+    m_IsParsered = false;
     m_TextBuf.Clear();
     m_charList.RemoveAll();
     m_pPreTextObj = NULL;
     ProcessObject();
-    m_IsParsered = TRUE;
+    m_IsParsered = true;
     if(!m_ParseOptions.m_bGetCharCodeOnly) {
         m_CharIndex.RemoveAll();
         int nCount = m_charList.GetSize();
@@ -197,15 +197,15 @@ FX_BOOL CPDF_TextPage::ParseTextPage()
         }
         for(int i = 0; i < nCount; i++) {
             int indexSize = m_CharIndex.GetSize();
-            FX_BOOL bNormal = FALSE;
+            bool bNormal = false;
             PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(i);
             if(charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
-                bNormal = TRUE;
+                bNormal = true;
             }
             else if(charinfo.m_Unicode == 0 || IsControlChar(charinfo))
-                bNormal = FALSE;
+                bNormal = false;
             else {
-                bNormal = TRUE;
+                bNormal = true;
             }
             if(bNormal) {
                 if(indexSize % 2) {
@@ -232,7 +232,7 @@ FX_BOOL CPDF_TextPage::ParseTextPage()
             m_CharIndex.RemoveAt(indexSize - 1);
         }
     }
-    return TRUE;
+    return true;
 }
 int	CPDF_TextPage::CountChars() const
 {
@@ -283,7 +283,7 @@ void CPDF_TextPage::GetRectArray(int start, int nCount, CFX_RectArray& rectArray
     CPDF_TextObject*	pCurObj = NULL;
     CFX_FloatRect		rect;
     int					curPos = start;
-    FX_BOOL				flagNewRect = TRUE;
+    bool				flagNewRect = true;
     if (nCount + start > m_charList.GetSize() || nCount == -1) {
         nCount = m_charList.GetSize() - start;
     }
@@ -301,7 +301,7 @@ void CPDF_TextPage::GetRectArray(int start, int nCount, CFX_RectArray& rectArray
         if (pCurObj != info_curchar.m_pTextObj) {
             rectArray.Add(rect);
             pCurObj = info_curchar.m_pTextObj;
-            flagNewRect = TRUE;
+            flagNewRect = true;
         }
         if (flagNewRect) {
             FX_FLOAT orgX = info_curchar.m_OriginX, orgY = info_curchar.m_OriginY;
@@ -326,7 +326,7 @@ void CPDF_TextPage::GetRectArray(int start, int nCount, CFX_RectArray& rectArray
             } else {
                 rect.top = info_curchar.m_CharBox.top;
             }
-            flagNewRect = FALSE;
+            flagNewRect = false;
             rect = info_curchar.m_CharBox;
             rect.Normalize();
         } else {
@@ -399,8 +399,8 @@ CFX_WideString CPDF_TextPage::GetTextByRect(const CFX_FloatRect& rect) const
     int nCount = m_charList.GetSize();
     int pos = 0;
     FX_FLOAT posy = 0;
-    FX_BOOL IsContainPreChar = FALSE;
-    FX_BOOL	ISAddLineFeed = FALSE;
+    bool IsContainPreChar = false;
+    bool	ISAddLineFeed = false;
     while (pos < nCount) {
         PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(pos++);
         if (IsRectIntersect(rect, charinfo.m_CharBox)) {
@@ -410,20 +410,20 @@ CFX_WideString CPDF_TextPage::GetTextByRect(const CFX_FloatRect& rect) const
                     strText += L"\r\n";
                 }
             }
-            IsContainPreChar = TRUE;
-            ISAddLineFeed = FALSE;
+            IsContainPreChar = true;
+            ISAddLineFeed = false;
             if (charinfo.m_Unicode) {
                 strText += charinfo.m_Unicode;
             }
         } else if (charinfo.m_Unicode == 32) {
             if (IsContainPreChar && charinfo.m_Unicode) {
                 strText += charinfo.m_Unicode;
-                IsContainPreChar = FALSE;
-                ISAddLineFeed = FALSE;
+                IsContainPreChar = false;
+                ISAddLineFeed = false;
             }
         } else {
-            IsContainPreChar = FALSE;
-            ISAddLineFeed = TRUE;
+            IsContainPreChar = false;
+            ISAddLineFeed = true;
         }
     }
     return strText;
@@ -437,7 +437,7 @@ void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect, CFX_RectArray
         return;
     }
     CFX_FloatRect		curRect;
-    FX_BOOL				flagNewRect = TRUE;
+    bool				flagNewRect = true;
     CPDF_TextObject*	pCurObj = NULL;
     int nCount = m_charList.GetSize();
     int pos = 0;
@@ -453,11 +453,11 @@ void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect, CFX_RectArray
             if (pCurObj != info_curchar.m_pTextObj) {
                 resRectArray.Add(curRect);
                 pCurObj = info_curchar.m_pTextObj;
-                flagNewRect = TRUE;
+                flagNewRect = true;
             }
             if (flagNewRect) {
                 curRect = info_curchar.m_CharBox;
-                flagNewRect = FALSE;
+                flagNewRect = false;
                 curRect.Normalize();
             } else {
                 info_curchar.m_CharBox.Normalize();
@@ -626,13 +626,13 @@ void CPDF_TextPage::GetRect(int rectIndex, FX_FLOAT& left, FX_FLOAT& top, FX_FLO
     right = m_SelRects.GetAt(rectIndex).right;
     bottom = m_SelRects.GetAt(rectIndex).bottom;
 }
-FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate)
+bool CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate)
 {
     if(m_ParseOptions.m_bGetCharCodeOnly) {
-        return FALSE;
+        return false;
     }
     if(end == start) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT dx, dy;
     FPDF_CHAR_INFO info1, info2;
@@ -641,7 +641,7 @@ FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate)
     while(info2.m_CharBox.Width() == 0 || info2.m_CharBox.Height() == 0) {
         end--;
         if(end <= start) {
-            return FALSE;
+            return false;
         }
         GetCharInfo(end, info2);
     }
@@ -664,16 +664,16 @@ FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate)
     } else if(Rotate > 0) {
         Rotate = 360 - Rotate;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL	CPDF_TextPage::GetBaselineRotate(const CFX_FloatRect& rect , int& Rotate)
+bool	CPDF_TextPage::GetBaselineRotate(const CFX_FloatRect& rect , int& Rotate)
 {
     if(m_ParseOptions.m_bGetCharCodeOnly) {
-        return FALSE;
+        return false;
     }
-    int start, end, count, n = CountBoundedSegments(rect.left, rect.top, rect.right, rect.bottom, TRUE);
+    int start, end, count, n = CountBoundedSegments(rect.left, rect.top, rect.right, rect.bottom, true);
     if(n < 1) {
-        return FALSE;
+        return false;
     }
     if(n > 1) {
         GetBoundedSegment(n - 1, start, count);
@@ -685,18 +685,18 @@ FX_BOOL	CPDF_TextPage::GetBaselineRotate(const CFX_FloatRect& rect , int& Rotate
     }
     return GetBaselineRotate(start, end, Rotate);
 }
-FX_BOOL	CPDF_TextPage::GetBaselineRotate(int rectIndex, int& Rotate)
+bool	CPDF_TextPage::GetBaselineRotate(int rectIndex, int& Rotate)
 {
     if(m_ParseOptions.m_bGetCharCodeOnly) {
-        return FALSE;
+        return false;
     }
     if (!m_IsParsered || rectIndex < 0 || rectIndex > m_SelRects.GetSize()) {
-        return FALSE;
+        return false;
     }
     CFX_FloatRect rect = m_SelRects.GetAt(rectIndex);
     return GetBaselineRotate(rect , Rotate);
 }
-int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT right, FX_FLOAT bottom, FX_BOOL bContains )
+int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT right, FX_FLOAT bottom, bool bContains )
 {
     if(m_ParseOptions.m_bGetCharCodeOnly) {
         return -1;
@@ -712,8 +712,8 @@ int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT ri
     FPDF_SEGMENT	segment;
     segment.m_Start = 0;
     segment.m_nCount = 0;
-    FX_BOOL		segmentStatus = 0;
-    FX_BOOL		IsContainPreChar = FALSE;
+    bool		segmentStatus = 0;
+    bool		IsContainPreChar = false;
     while (pos < nCount) {
         PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(pos);
         if(bContains && rect.Contains(charinfo.m_CharBox)) {
@@ -724,7 +724,7 @@ int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT ri
             } else if (segmentStatus == 1) {
                 segment.m_nCount++;
             }
-            IsContainPreChar = TRUE;
+            IsContainPreChar = true;
         } else if (!bContains && (IsRectIntersect(rect, charinfo.m_CharBox) || rect.Contains(charinfo.m_OriginX, charinfo.m_OriginY))) {
             if (segmentStatus == 0 || segmentStatus == 2) {
                 segment.m_Start = pos;
@@ -733,9 +733,9 @@ int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT ri
             } else if (segmentStatus == 1) {
                 segment.m_nCount++;
             }
-            IsContainPreChar = TRUE;
+            IsContainPreChar = true;
         } else if (charinfo.m_Unicode == 32) {
-            if (IsContainPreChar == TRUE) {
+            if (IsContainPreChar == true) {
                 if (segmentStatus == 0 || segmentStatus == 2) {
                     segment.m_Start = pos;
                     segment.m_nCount = 1;
@@ -743,7 +743,7 @@ int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT ri
                 } else if (segmentStatus == 1) {
                     segment.m_nCount++;
                 }
-                IsContainPreChar = FALSE;
+                IsContainPreChar = false;
             } else {
                 if (segmentStatus == 1) {
                     segmentStatus = 2;
@@ -759,7 +759,7 @@ int	CPDF_TextPage::CountBoundedSegments(FX_FLOAT left, FX_FLOAT top, FX_FLOAT ri
                 segment.m_Start = 0;
                 segment.m_nCount = 0;
             }
-            IsContainPreChar = FALSE;
+            IsContainPreChar = false;
         }
         pos++;
     }
@@ -1053,7 +1053,7 @@ void CPDF_TextPage::AddCharInfoByRLDirection(CFX_WideString& str, int i)
     PAGECHAR_INFO Info = *(PAGECHAR_INFO*)m_TempCharList.GetAt(i);
     if(!IsControlChar(Info)) {
         Info.m_Index = m_TextBuf.GetLength();
-        FX_WCHAR wChar = FX_GetMirrorChar(str.GetAt(i), TRUE, FALSE);
+        FX_WCHAR wChar = FX_GetMirrorChar(str.GetAt(i), true, false);
         FX_WCHAR* pDst = NULL;
         FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
         if (nCount >= 1) {
@@ -1089,10 +1089,10 @@ void CPDF_TextPage::CloseTempLine()
     nonstd::unique_ptr<IFX_BidiChar> pBidiChar(IFX_BidiChar::Create());
     CFX_WideString str = m_TempTextBuf.GetWideString();
     CFX_WordArray order;
-    FX_BOOL bR2L = FALSE;
+    bool bR2L = false;
     int32_t start = 0, count = 0;
     int nR2L = 0, nL2R = 0;
-    FX_BOOL bPrevSpace = FALSE;
+    bool bPrevSpace = false;
     for (int i = 0; i < str.GetLength(); i++) {
         if(str.GetAt(i) == 32) {
             if(bPrevSpace) {
@@ -1103,9 +1103,9 @@ void CPDF_TextPage::CloseTempLine()
                 i--;
                 continue;
             }
-            bPrevSpace = TRUE;
+            bPrevSpace = true;
         } else {
-            bPrevSpace = FALSE;
+            bPrevSpace = false;
         }
         if(pBidiChar->AppendChar(str.GetAt(i))) {
             int32_t ret = pBidiChar->GetBidiInfo(start, count);
@@ -1135,7 +1135,7 @@ void CPDF_TextPage::CloseTempLine()
         }
     }
     if(nR2L > 0 && nR2L >= nL2R) {
-        bR2L = TRUE;
+        bR2L = true;
     }
     if (m_parserflag == FPDFTEXT_RLTB || bR2L) {
         int count = order.GetSize();
@@ -1149,7 +1149,7 @@ void CPDF_TextPage::CloseTempLine()
                 }
             } else {
                 int j = i;
-                FX_BOOL bSymbol = FALSE;
+                bool bSymbol = false;
                 while(j > 0 && order.GetAt(j) != 2) {
                     bSymbol = !order.GetAt(j);
                     j -= 3;
@@ -1181,7 +1181,7 @@ void CPDF_TextPage::CloseTempLine()
         }
     } else {
         int count = order.GetSize();
-        FX_BOOL bL2R = FALSE;
+        bool bL2R = false;
         for(int i = 0; i < count; i += 3) {
             int ret = order.GetAt(i + 2);
             int start = order.GetAt(i);
@@ -1197,7 +1197,7 @@ void CPDF_TextPage::CloseTempLine()
                 }
                 if(j == 3) {
                     i = -3;
-                    bL2R = TRUE;
+                    bL2R = true;
                     continue;
                 }
                 int end = m_TempCharList.GetSize() - 1;
@@ -1307,7 +1307,7 @@ int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj)
         return FPDFTEXT_MC_PASS;
     }
     CFX_WideString actText;
-    FX_BOOL bExist = FALSE;
+    bool bExist = false;
     CPDF_Dictionary* pDict = NULL;
     int n = 0;
     for (n = 0; n < nContentMark; n++) {
@@ -1316,7 +1316,7 @@ int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj)
         pDict = (CPDF_Dictionary*)item.GetParam();
         CPDF_String* temp = (CPDF_String*)(pDict ? pDict->GetElement(FX_BSTRC("ActualText")) : NULL);
         if (temp) {
-            bExist = TRUE;
+            bExist = true;
             actText = temp->GetUnicodeText();
         }
     }
@@ -1338,24 +1338,24 @@ int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj)
     if (nItems < 1) {
         return FPDFTEXT_MC_PASS;
     }
-    bExist = FALSE;
+    bExist = false;
     for (FX_STRSIZE i = 0; i < nItems; i++) {
         FX_WCHAR wChar = actText.GetAt(i);
         if (-1 == pFont->CharCodeFromUnicode(wChar)) {
             continue;
         } else {
-            bExist = TRUE;
+            bExist = true;
             break;
         }
     }
     if (!bExist) {
         return FPDFTEXT_MC_PASS;
     }
-    bExist = FALSE;
+    bExist = false;
     for (FX_STRSIZE i = 0; i < nItems; i++) {
         FX_WCHAR wChar = actText.GetAt(i);
         if ((wChar > 0x80 && wChar < 0xFFFD) || (wChar <= 0x80 && isprint(wChar))) {
-            bExist = TRUE;
+            bExist = true;
             break;
         }
     }
@@ -1539,8 +1539,8 @@ void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj)
     int nItems = pTextObj->CountItems();
     FX_FLOAT baseSpace = _CalculateBaseSpace(pTextObj, matrix);
 
-    const FX_BOOL bR2L = IsRightToLeft(pTextObj, pFont, nItems);
-    const FX_BOOL bIsBidiAndMirrorInverse =
+    const bool bR2L = IsRightToLeft(pTextObj, pFont, nItems);
+    const bool bIsBidiAndMirrorInverse =
         bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
     int32_t iBufStartAppend = m_TempTextBuf.GetLength();
     int32_t iCharListStartAppend = m_TempCharList.GetSize();
@@ -1609,7 +1609,7 @@ void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj)
         }
         spacing = 0;
         CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
-        FX_BOOL bNoUnicode = FALSE;
+        bool bNoUnicode = false;
         FX_WCHAR wChar = wstrItem.GetAt(0);
         if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode) {
             if(wstrItem.IsEmpty()) {
@@ -1617,7 +1617,7 @@ void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj)
             } else {
                 wstrItem.SetAt(0, (FX_WCHAR)item.m_CharCode);
             }
-            bNoUnicode = TRUE;
+            bNoUnicode = true;
         }
         charinfo.m_Index = -1;
         charinfo.m_CharCode = item.m_CharCode;
@@ -1651,7 +1651,7 @@ void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj)
             continue;
         } else {
             int nTotal = wstrItem.GetLength();
-            FX_BOOL bDel = FALSE;
+            bool bDel = false;
             const int count = std::min(m_TempCharList.GetSize(), 7);
             FX_FLOAT threshold = charinfo.m_Matrix.TransformXDistance((FX_FLOAT)TEXT_CHARRATIO_GAPDELTA * pTextObj->GetFontSize());
             for (int n = m_TempCharList.GetSize();
@@ -1662,7 +1662,7 @@ void CPDF_TextPage::ProcessTextObject(PDFTEXT_Obj Obj)
                         charinfo1->m_pTextObj->GetFont() == charinfo.m_pTextObj->GetFont()  &&
                         FXSYS_fabs(charinfo1->m_OriginX - charinfo.m_OriginX) < threshold  &&
                         FXSYS_fabs(charinfo1->m_OriginY - charinfo.m_OriginY) < threshold) {
-                    bDel = TRUE;
+                    bDel = true;
                     break;
                 }
             }
@@ -1707,7 +1707,7 @@ void CPDF_TextPage::SwapTempTextBuf(int32_t iCharListStartAppend,
         std::swap(pTempBuffer[i], pTempBuffer[j]);
     }
 }
-FX_BOOL CPDF_TextPage::IsRightToLeft(const CPDF_TextObject* pTextObj,
+bool CPDF_TextPage::IsRightToLeft(const CPDF_TextObject* pTextObj,
                                      const CPDF_Font* pFont,
                                      int nItems) const
 {
@@ -1779,7 +1779,7 @@ int32_t CPDF_TextPage::GetTextObjectWritingMode(const CPDF_TextObject* pTextObj)
     }
     return m_TextlineDir;
 }
-FX_BOOL CPDF_TextPage::IsHyphen(FX_WCHAR curChar)
+bool CPDF_TextPage::IsHyphen(FX_WCHAR curChar)
 {
     CFX_WideString strCurText = m_TempTextBuf.GetWideString();
     if(strCurText.GetLength() == 0) {
@@ -1796,7 +1796,7 @@ FX_BOOL CPDF_TextPage::IsHyphen(FX_WCHAR curChar)
             FX_WCHAR preChar = strCurText.GetAt((nIndex));
             if (((preChar >= L'A' && preChar <= L'Z') || (preChar >= L'a' && preChar <= L'z'))
                     && ((curChar >= L'A' && curChar <= L'Z') || (curChar >= L'a' && curChar <= L'z'))) {
-                return TRUE;
+                return true;
             }
         }
         int size = m_TempCharList.GetSize();
@@ -1806,21 +1806,21 @@ FX_BOOL CPDF_TextPage::IsHyphen(FX_WCHAR curChar)
         } else {
             size = m_charList.GetSize();
             if(size == 0) {
-                return FALSE;
+                return false;
             }
             preChar = (PAGECHAR_INFO)m_charList[size - 1];
         }
         if (FPDFTEXT_CHAR_PIECE == preChar.m_Flag)
             if (0xAD == preChar.m_Unicode || 0x2D == preChar.m_Unicode) {
-                return TRUE;
+                return true;
             }
     }
-    return FALSE;
+    return false;
 }
 int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj, const CFX_AffineMatrix& formMatrix)
 {
     FindPreviousTextObject();
-    FX_BOOL bNewline = FALSE;
+    bool bNewline = false;
     int WritingMode = GetTextObjectWritingMode(pObj);
     if(WritingMode == -1) {
         WritingMode = GetTextObjectWritingMode(m_pPreTextObj);
@@ -1884,8 +1884,8 @@ int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj, const CFX_Af
     rect1.Intersect(rect2);
     if (WritingMode == 0) {
         if ((rect1.IsEmpty() && rect2.Height() > 5 && rect3.Height() > 5)
-                || ((y > threshold * 2 || y < threshold * -3) && (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : TRUE))) {
-            bNewline = TRUE;
+                || ((y > threshold * 2 || y < threshold * -3) && (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : true))) {
+            bNewline = true;
             if(nItem > 1 ) {
                 CPDF_TextObjectItem tempItem;
                 m_pPreTextObj->GetItemInfo(0, &tempItem);
@@ -1897,11 +1897,11 @@ int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj, const CFX_Af
                         && m.b < 0.1 && m.c < 0.1 ) {
                     CFX_FloatRect re(0, m_pPreTextObj->m_Bottom, 1000, m_pPreTextObj->m_Top);
                     if(re.Contains(pObj->GetPosX(), pObj->GetPosY())) {
-                        bNewline = FALSE;
+                        bNewline = false;
                     } else {
                         CFX_FloatRect re(0, pObj->m_Bottom, 1000, pObj->m_Top);
                         if(re.Contains(m_pPreTextObj->GetPosX(), m_pPreTextObj->GetPosY())) {
-                            bNewline = FALSE;
+                            bNewline = false;
                         }
                     }
                 }
@@ -1952,10 +1952,10 @@ int CPDF_TextPage::ProcessInsertObject(const CPDF_TextObject* pObj, const CFX_Af
         }
     return 0;
 }
-FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2)
+bool CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2)
 {
     if (!pTextObj1 || !pTextObj2) {
-        return FALSE;
+        return false;
     }
     CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom, pTextObj2->m_Right, pTextObj2->m_Top);
     CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom, pTextObj1->m_Right, pTextObj1->m_Top);
@@ -1966,46 +1966,46 @@ FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObj
             PAGECHAR_INFO perCharTemp = (PAGECHAR_INFO)m_charList[nCount - 2];
             FX_FLOAT dbSpace = perCharTemp.m_CharBox.Width();
             if (dbXdif > dbSpace) {
-                return FALSE;
+                return false;
             }
         }
     }
     if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
         rcPreObj.Intersect(rcCurObj);
         if (rcPreObj.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) > rcCurObj.Width() / 2) {
-            return FALSE;
+            return false;
         }
         if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize()) {
-            return FALSE;
+            return false;
         }
     }
     int nPreCount = pTextObj2->CountItems();
     int nCurCount = pTextObj1->CountItems();
     if (nPreCount != nCurCount) {
-        return FALSE;
+        return false;
     }
     CPDF_TextObjectItem itemPer, itemCur;
     for (int i = 0; i < nPreCount; i++) {
         pTextObj2->GetItemInfo(i, &itemPer);
         pTextObj1->GetItemInfo(i, &itemCur);
         if (itemCur.m_CharCode != itemPer.m_CharCode) {
-            return FALSE;
+            return false;
         }
     }
     if(FXSYS_fabs(pTextObj1->GetPosX() - pTextObj2->GetPosX()) > GetCharWidth(itemPer.m_CharCode, pTextObj2->GetFont())*pTextObj2->GetFontSize() / 1000 * 0.9 ||
             FXSYS_fabs(pTextObj1->GetPosY() - pTextObj2->GetPosY()) >
             FX_MAX(FX_MAX(rcPreObj.Height() , rcPreObj.Width()), pTextObj2->GetFontSize()) / 8) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_TextPage::IsSameAsPreTextObject(CPDF_TextObject* pTextObj, FX_POSITION ObjPos)
+bool CPDF_TextPage::IsSameAsPreTextObject(CPDF_TextObject* pTextObj, FX_POSITION ObjPos)
 {
     if (!pTextObj) {
-        return FALSE;
+        return false;
     }
     int i = 0;
     if (!ObjPos) {
@@ -2021,13 +2021,13 @@ FX_BOOL CPDF_TextPage::IsSameAsPreTextObject(CPDF_TextObject* pTextObj, FX_POSIT
             continue;
         }
         if(IsSameTextObject((CPDF_TextObject*)pObj, pTextObj)) {
-            return TRUE;
+            return true;
         }
         i++;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info)
+bool CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info)
 {
     int size = m_TempCharList.GetSize();
     PAGECHAR_INFO preChar;
@@ -2036,7 +2036,7 @@ FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info)
     } else {
         size = m_charList.GetSize();
         if(size == 0) {
-            return FALSE;
+            return false;
         }
         preChar = (PAGECHAR_INFO)m_charList[size - 1];
     }
@@ -2061,37 +2061,37 @@ FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info)
     info.m_OriginX = preChar.m_OriginX + preWidth * (fs) / 1000;
     info.m_OriginY = preChar.m_OriginY;
     info.m_CharBox = CFX_FloatRect(info.m_OriginX, info.m_OriginY, info.m_OriginX, info.m_OriginY);
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1, const CFX_FloatRect& rect2)
+bool CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1, const CFX_FloatRect& rect2)
 {
     CFX_FloatRect rect = rect1;
     rect.Intersect(rect2);
     return !rect.IsEmpty();
 }
-FX_BOOL	CPDF_TextPage::IsLetter(FX_WCHAR unicode)
+bool	CPDF_TextPage::IsLetter(FX_WCHAR unicode)
 {
     if (unicode < L'A') {
-        return FALSE;
+        return false;
     }
     if (unicode > L'Z' && unicode < L'a') {
-        return FALSE;
+        return false;
     }
     if (unicode > L'z') {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 CPDF_TextPageFind::CPDF_TextPageFind(const IPDF_TextPage* pTextPage)
     : m_pTextPage(pTextPage),
       m_flags(0),
       m_findNextStart(-1),
       m_findPreStart(-1),
-      m_bMatchCase(FALSE),
-      m_bMatchWholeWord(FALSE),
+      m_bMatchCase(false),
+      m_bMatchWholeWord(false),
       m_resStart(0),
       m_resEnd(-1),
-      m_IsFind(FALSE)
+      m_IsFind(false)
 {
     m_strText = m_pTextPage->GetPageText();
     int nCount = pTextPage->CountChars();
@@ -2140,10 +2140,10 @@ int CPDF_TextPageFind::GetCharIndex(int index) const
     }
     return -1;
 }
-FX_BOOL	CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat, int flags, int startPos)
+bool	CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat, int flags, int startPos)
 {
     if (!m_pTextPage) {
-        return FALSE;
+        return false;
     }
     if (m_strText.IsEmpty() || m_bMatchCase != (flags & FPDFTEXT_MATCHCASE)) {
         m_strText = m_pTextPage->GetPageText();
@@ -2153,8 +2153,8 @@ FX_BOOL	CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat, int flags,
     m_flags = flags;
     m_bMatchCase = flags & FPDFTEXT_MATCHCASE;
     if (m_strText.IsEmpty()) {
-        m_IsFind = FALSE;
-        return TRUE;
+        m_IsFind = false;
+        return true;
     }
     FX_STRSIZE len = findwhatStr.GetLength();
     if (!m_bMatchCase) {
@@ -2182,36 +2182,36 @@ FX_BOOL	CPDF_TextPageFind::FindFirst(const CFX_WideString& findwhat, int flags,
         m_csFindWhatArray.Add(findwhatStr);
     }
     if(m_csFindWhatArray.GetSize() <= 0) {
-        return FALSE;
+        return false;
     }
-    m_IsFind = TRUE;
+    m_IsFind = true;
     m_resStart = 0;
     m_resEnd = -1;
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_TextPageFind::FindNext()
+bool CPDF_TextPageFind::FindNext()
 {
     if (!m_pTextPage) {
-        return FALSE;
+        return false;
     }
     m_resArray.RemoveAll();
     if(m_findNextStart == -1) {
-        return FALSE;
+        return false;
     }
     if(m_strText.IsEmpty()) {
-        m_IsFind = FALSE;
+        m_IsFind = false;
         return m_IsFind;
     }
     int strLen = m_strText.GetLength();
     if (m_findNextStart > strLen - 1) {
-        m_IsFind = FALSE;
+        m_IsFind = false;
         return m_IsFind;
     }
     int nCount = m_csFindWhatArray.GetSize();
     int nResultPos = 0;
     int	nStartPos = 0;
     nStartPos = m_findNextStart;
-    FX_BOOL bSpaceStart = FALSE;
+    bool bSpaceStart = false;
     for(int iWord = 0; iWord < nCount; iWord++) {
         CFX_WideString csWord = m_csFindWhatArray[iWord];
         if(csWord.IsEmpty()) {
@@ -2223,33 +2223,33 @@ FX_BOOL CPDF_TextPageFind::FindNext()
                 }
                 iWord = -1;
             } else if(iWord == 0) {
-                bSpaceStart = TRUE;
+                bSpaceStart = true;
             }
             continue;
         }
         int endIndex;
         nResultPos = m_strText.Find(csWord.c_str(), nStartPos);
         if (nResultPos == -1) {
-            m_IsFind = FALSE;
+            m_IsFind = false;
             return m_IsFind;
         }
         endIndex = nResultPos + csWord.GetLength() - 1;
         if(iWord == 0) {
             m_resStart = nResultPos;
         }
-        FX_BOOL bMatch = TRUE;
+        bool bMatch = true;
         if(iWord != 0 && !bSpaceStart) {
             int PreResEndPos = nStartPos;
             int curChar = csWord.GetAt(0);
             CFX_WideString lastWord = m_csFindWhatArray[iWord - 1];
             int lastChar = lastWord.GetAt(lastWord.GetLength() - 1);
             if(nStartPos == nResultPos && !(_IsIgnoreSpaceCharacter(lastChar) || _IsIgnoreSpaceCharacter(curChar))) {
-                bMatch = FALSE;
+                bMatch = false;
             }
             for(int d = PreResEndPos; d < nResultPos; d++) {
                 FX_WCHAR strInsert = m_strText.GetAt(d);
                 if(strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_BLANK_CHAR && strInsert != TEXT_RETURN_CHAR && strInsert != 160) {
-                    bMatch = FALSE;
+                    bMatch = false;
                     break;
                 }
             }
@@ -2257,7 +2257,7 @@ FX_BOOL CPDF_TextPageFind::FindNext()
             if(nResultPos > 0) {
                 FX_WCHAR strInsert = m_strText.GetAt(nResultPos - 1);
                 if(strInsert != TEXT_LINEFEED_CHAR && strInsert != TEXT_BLANK_CHAR && strInsert != TEXT_RETURN_CHAR && strInsert != 160) {
-                    bMatch = FALSE;
+                    bMatch = false;
                     m_resStart = nResultPos;
                 } else {
                     m_resStart = nResultPos - 1;
@@ -2278,7 +2278,7 @@ FX_BOOL CPDF_TextPageFind::FindNext()
         }
     }
     m_resEnd = nResultPos + m_csFindWhatArray[m_csFindWhatArray.GetSize() - 1].GetLength() - 1;
-    m_IsFind = TRUE;
+    m_IsFind = true;
     int resStart = GetCharIndex(m_resStart);
     int resEnd = GetCharIndex(m_resEnd);
     m_pTextPage->GetRectArray(resStart, resEnd - resStart + 1, m_resArray);
@@ -2291,20 +2291,20 @@ FX_BOOL CPDF_TextPageFind::FindNext()
     }
     return m_IsFind;
 }
-FX_BOOL CPDF_TextPageFind::FindPrev()
+bool CPDF_TextPageFind::FindPrev()
 {
     if (!m_pTextPage) {
-        return FALSE;
+        return false;
     }
     m_resArray.RemoveAll();
     if(m_strText.IsEmpty() || m_findPreStart < 0) {
-        m_IsFind = FALSE;
+        m_IsFind = false;
         return m_IsFind;
     }
     CPDF_TextPageFind findEngine(m_pTextPage);
-    FX_BOOL ret = findEngine.FindFirst(m_findWhat, m_flags);
+    bool ret = findEngine.FindFirst(m_findWhat, m_flags);
     if(!ret) {
-        m_IsFind = FALSE;
+        m_IsFind = false;
         return m_IsFind;
     }
     int	order = -1, MatchedCount = 0;
@@ -2321,12 +2321,12 @@ FX_BOOL CPDF_TextPageFind::FindPrev()
         }
     }
     if(order == -1) {
-        m_IsFind = FALSE;
+        m_IsFind = false;
         return m_IsFind;
     }
     m_resStart = m_pTextPage->TextIndexFromCharIndex(order);
     m_resEnd = m_pTextPage->TextIndexFromCharIndex(order + MatchedCount - 1);
-    m_IsFind = TRUE;
+    m_IsFind = true;
     m_pTextPage->GetRectArray(order, MatchedCount, m_resArray);
     if(m_flags & FPDFTEXT_CONSECUTIVE) {
         m_findNextStart = m_resStart + 1;
@@ -2385,16 +2385,16 @@ void CPDF_TextPageFind::ExtractFindWhat(const CFX_WideString& findwhat)
         index++;
     }
 }
-FX_BOOL CPDF_TextPageFind::IsMatchWholeWord(const CFX_WideString& csPageText, int startPos, int endPos)
+bool CPDF_TextPageFind::IsMatchWholeWord(const CFX_WideString& csPageText, int startPos, int endPos)
 {
     int char_left = 0;
     int char_right = 0;
     int char_count = endPos - startPos + 1;
     if(char_count < 1) {
-        return FALSE;
+        return false;
     }
     if (char_count == 1 && csPageText.GetAt(startPos) > 255) {
-        return TRUE;
+        return true;
     }
     if(startPos - 1 >= 0 ) {
         char_left = csPageText.GetAt(startPos - 1);
@@ -2404,33 +2404,33 @@ FX_BOOL CPDF_TextPageFind::IsMatchWholeWord(const CFX_WideString& csPageText, in
     }
     if ((char_left > 'A' && char_left < 'a') || (char_left > 'a' && char_left < 'z') || (char_left > 0xfb00 && char_left < 0xfb06) || (char_left >= '0' && char_left <= '9') ||
             (char_right > 'A' && char_right < 'a') || (char_right > 'a' && char_right < 'z') || (char_right > 0xfb00 && char_right < 0xfb06) || (char_right >= '0' && char_right <= '9')) {
-        return FALSE;
+        return false;
     }
     if(!(('A' > char_left || char_left > 'Z')  && ('a' > char_left || char_left > 'z')
             && ('A' > char_right || char_right > 'Z')  && ('a' > char_right || char_right > 'z'))) {
-        return FALSE;
+        return false;
     }
     if (char_count > 0) {
         if (csPageText.GetAt(startPos) >= L'0' && csPageText.GetAt(startPos) <= L'9' && char_left >= L'0' && char_left <= L'9') {
-            return FALSE;
+            return false;
         }
         if (csPageText.GetAt(endPos) >= L'0' && csPageText.GetAt(endPos) <= L'9' && char_right >= L'0' && char_right <= L'9') {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString, const FX_WCHAR* lpszFullString,
+bool CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString, const FX_WCHAR* lpszFullString,
         int iSubString, FX_WCHAR chSep)
 {
     if (lpszFullString == NULL) {
-        return FALSE;
+        return false;
     }
     while (iSubString--) {
         lpszFullString = FXSYS_wcschr(lpszFullString, chSep);
         if (lpszFullString == NULL) {
             rString.Empty();
-            return FALSE;
+            return false;
         }
         lpszFullString++;
         while(*lpszFullString == chSep) {
@@ -2443,7 +2443,7 @@ FX_BOOL CPDF_TextPageFind::ExtractSubString(CFX_WideString& rString, const FX_WC
     ASSERT(nLen >= 0);
     FXSYS_memcpy(rString.GetBuffer(nLen), lpszFullString, nLen * sizeof(FX_WCHAR));
     rString.ReleaseBuffer();
-    return TRUE;
+    return true;
 }
 CFX_WideString CPDF_TextPageFind::MakeReverse(const CFX_WideString& str)
 {
@@ -2471,27 +2471,27 @@ int	CPDF_TextPageFind::GetMatchedCount()const
 }
 CPDF_LinkExtract::CPDF_LinkExtract()
     : m_pTextPage(NULL),
-      m_IsParserd(FALSE)
+      m_IsParserd(false)
 {
 }
 CPDF_LinkExtract::~CPDF_LinkExtract()
 {
     DeleteLinkList();
 }
-FX_BOOL CPDF_LinkExtract::ExtractLinks(const IPDF_TextPage* pTextPage)
+bool CPDF_LinkExtract::ExtractLinks(const IPDF_TextPage* pTextPage)
 {
     if (!pTextPage || !pTextPage->IsParsered()) {
-        return FALSE;
+        return false;
     }
     m_pTextPage = (const CPDF_TextPage*)pTextPage;
     m_strPageText = m_pTextPage->GetPageText(0, -1);
     DeleteLinkList();
     if (m_strPageText.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     parserLink();
-    m_IsParserd = TRUE;
-    return TRUE;
+    m_IsParserd = true;
+    return true;
 }
 void CPDF_LinkExtract::DeleteLinkList()
 {
@@ -2546,42 +2546,42 @@ void CPDF_LinkExtract::parserLink()
         }
     }
 }
-FX_BOOL CPDF_LinkExtract::CheckWebLink(CFX_WideString& strBeCheck)
+bool CPDF_LinkExtract::CheckWebLink(CFX_WideString& strBeCheck)
 {
     CFX_WideString str = strBeCheck;
     str.MakeLower();
     if (str.Find(L"http://www.") != -1) {
         strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"http://www."));
-        return TRUE;
+        return true;
     }
     if (str.Find(L"http://") != -1) {
         strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"http://"));
-        return TRUE;
+        return true;
     }
     if (str.Find(L"https://www.") != -1) {
         strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://www."));
-        return TRUE;
+        return true;
     }
     if (str.Find(L"https://") != -1) {
         strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"https://"));
-        return TRUE;
+        return true;
     }
     if (str.Find(L"www.") != -1) {
         strBeCheck = strBeCheck.Right(str.GetLength() - str.Find(L"www."));
         strBeCheck = L"http://" + strBeCheck;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
+bool CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
 {
     str.MakeLower();
     int aPos = str.Find(L'@');
     if (aPos < 1) {
-        return FALSE;
+        return false;
     }
     if (str.GetAt(aPos - 1) == L'.' || str.GetAt(aPos - 1) == L'_') {
-        return FALSE;
+        return false;
     }
     int i;
     for (i = aPos - 1; i >= 0; i--) {
@@ -2590,7 +2590,7 @@ FX_BOOL CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
             continue;
         } else {
             if (i == aPos - 1) {
-                return FALSE;
+                return false;
             }
             str = str.Right(str.GetLength() - i - 1);
             break;
@@ -2598,7 +2598,7 @@ FX_BOOL CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
     }
     aPos = str.Find(L'@');
     if (aPos < 1) {
-        return FALSE;
+        return false;
     }
     CFX_WideString strtemp = L"";
     for (i = 0; i < aPos; i++) {
@@ -2614,13 +2614,13 @@ FX_BOOL CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
     }
     aPos = str.Find(L'@');
     if (aPos < 1) {
-        return FALSE;
+        return false;
     }
     str.TrimRight(L'.');
     strtemp = str;
     int ePos = str.Find(L'.');
     if (ePos == -1) {
-        return FALSE;
+        return false;
     }
     while (ePos != -1) {
         strtemp = strtemp.Right(strtemp.GetLength() - ePos - 1);
@@ -2643,22 +2643,22 @@ FX_BOOL CPDF_LinkExtract::CheckMailLink(CFX_WideString& str)
         if (wch == L'-' || wch == L'.' || (wch >= L'a' && wch <= L'z') || (wch >= L'0' && wch <= L'9')) {
             continue;
         } else {
-            return FALSE;
+            return false;
         }
     }
     if (str.Find(L"mailto:") == -1) {
         str = L"mailto:" + str;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_LinkExtract::AppendToLinkList(int start, int count, const CFX_WideString& strUrl)
+bool CPDF_LinkExtract::AppendToLinkList(int start, int count, const CFX_WideString& strUrl)
 {
     CPDF_LinkExt* linkInfo = new CPDF_LinkExt;
     linkInfo->m_strUrl = strUrl;
     linkInfo->m_Start = start;
     linkInfo->m_Count = count;
     m_LinkList.Add(linkInfo);
-    return TRUE;
+    return true;
 }
 CFX_WideString CPDF_LinkExtract::GetURL(int index) const
 {
diff --git a/core/src/fpdftext/fpdf_text_search.cpp b/core/src/fpdftext/fpdf_text_search.cpp
index 21a2564ae6..d88e9e1760 100644
--- a/core/src/fpdftext/fpdf_text_search.cpp
+++ b/core/src/fpdftext/fpdf_text_search.cpp
@@ -9,56 +9,56 @@
 class CPDF_TextStream
 {
 public:
-    CPDF_TextStream(CFX_WideTextBuf& buffer, FX_BOOL bUseLF, CFX_PtrArray* pObjArray);
+    CPDF_TextStream(CFX_WideTextBuf& buffer, bool bUseLF, CFX_PtrArray* pObjArray);
     ~CPDF_TextStream() {}
-    FX_BOOL ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFirstLine);
+    bool ProcessObject(const CPDF_TextObject* pObj, bool bFirstLine);
     CFX_WideTextBuf&	m_Buffer;
-    FX_BOOL				m_bUseLF;
+    bool				m_bUseLF;
     CFX_PtrArray*		m_pObjArray;
     const CPDF_TextObject*	m_pLastObj;
 };
-CPDF_TextStream::CPDF_TextStream(CFX_WideTextBuf& buffer, FX_BOOL bUseLF, CFX_PtrArray* pObjArray) : m_Buffer(buffer)
+CPDF_TextStream::CPDF_TextStream(CFX_WideTextBuf& buffer, bool bUseLF, CFX_PtrArray* pObjArray) : m_Buffer(buffer)
 {
     m_pLastObj = NULL;
     m_bUseLF = bUseLF;
     m_pObjArray = pObjArray;
 }
-FX_BOOL FPDFText_IsSameTextObject(const CPDF_TextObject* pTextObj1, const CPDF_TextObject* pTextObj2)
+bool FPDFText_IsSameTextObject(const CPDF_TextObject* pTextObj1, const CPDF_TextObject* pTextObj2)
 {
     if (!pTextObj1 || !pTextObj2) {
-        return FALSE;
+        return false;
     }
     CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom, pTextObj2->m_Right, pTextObj2->m_Top);
     CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom, pTextObj1->m_Right, pTextObj1->m_Top);
     if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
         rcPreObj.Intersect(rcCurObj);
         if (rcPreObj.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) > rcCurObj.Width() / 2) {
-            return FALSE;
+            return false;
         }
         if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize()) {
-            return FALSE;
+            return false;
         }
     }
     int nPreCount = pTextObj2->CountItems();
     int nCurCount = pTextObj1->CountItems();
     if (nPreCount != nCurCount) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < nPreCount; i++) {
         CPDF_TextObjectItem itemPer, itemCur;
         pTextObj2->GetItemInfo(i, &itemPer);
         pTextObj1->GetItemInfo(i, &itemCur);
         if (itemCur.m_CharCode != itemPer.m_CharCode) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 int GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont)
 {
@@ -133,7 +133,7 @@ int FPDFText_ProcessInterObj(const CPDF_TextObject* pPrevObj, const CPDF_TextObj
     }
     return 0;
 }
-FX_BOOL CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFirstLine)
+bool CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, bool bFirstLine)
 {
     CPDF_Font* pFont = pObj->GetFont();
     CFX_AffineMatrix matrix;
@@ -150,7 +150,7 @@ FX_BOOL CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFir
                 }
             } else {
                 if (bFirstLine) {
-                    return TRUE;
+                    return true;
                 }
                 if (m_bUseLF) {
                     m_Buffer.AppendChar(L'\r');
@@ -176,7 +176,7 @@ FX_BOOL CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFir
             }
         } else if (result == -1) {
             m_pLastObj = pObj;
-            return FALSE;
+            return false;
         } else if (result == 3) {
             item_index = 1;
         }
@@ -277,9 +277,9 @@ FX_BOOL CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFir
             }
         }
     }
-    return FALSE;
+    return false;
 }
-void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, FX_BOOL bUseLF,
+void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, bool bUseLF,
                                 CFX_PtrArray* pObjArray)
 {
     CPDF_TextStream textstream(buffer, bUseLF, pObjArray);
@@ -292,7 +292,7 @@ void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage
         if (pObject->m_Type != PDFPAGE_TEXT) {
             continue;
         }
-        textstream.ProcessObject((CPDF_TextObject*)pObject, FALSE);
+        textstream.ProcessObject((CPDF_TextObject*)pObject, false);
     }
 }
 CFX_WideString PDF_GetFirstTextLine_Unicode(CPDF_Document* pDoc, CPDF_Dictionary* pPage)
@@ -302,17 +302,17 @@ CFX_WideString PDF_GetFirstTextLine_Unicode(CPDF_Document* pDoc, CPDF_Dictionary
     CPDF_Page page;
     page.Load(pDoc, pPage);
     CPDF_ParseOptions options;
-    options.m_bTextOnly = TRUE;
-    options.m_bSeparateForm = FALSE;
+    options.m_bTextOnly = true;
+    options.m_bSeparateForm = false;
     page.ParseContent(&options);
-    CPDF_TextStream textstream(buffer, FALSE, NULL);
+    CPDF_TextStream textstream(buffer, false, NULL);
     FX_POSITION pos = page.GetFirstObjectPosition();
     while (pos) {
         CPDF_PageObject* pObject = page.GetNextObject(pos);
         if (pObject->m_Type != PDFPAGE_TEXT) {
             continue;
         }
-        if (textstream.ProcessObject((CPDF_TextObject*)pObject, TRUE)) {
+        if (textstream.ProcessObject((CPDF_TextObject*)pObject, true)) {
             break;
         }
     }
diff --git a/core/src/fpdftext/text_int.h b/core/src/fpdftext/text_int.h
index ce52371df0..bcacc57863 100644
--- a/core/src/fpdftext/text_int.h
+++ b/core/src/fpdftext/text_int.h
@@ -48,9 +48,9 @@ public:
     CPDF_TextPage(const CPDF_Page* pPage, int flags = 0);
     CPDF_TextPage(const CPDF_PageObjects* pPage, int flags = 0);
     CPDF_TextPage(const CPDF_Page* pPage, CPDFText_ParseOptions ParserOptions);
-    virtual FX_BOOL					ParseTextPage();
-    virtual void					NormalizeObjects(FX_BOOL bNormalize);
-    virtual	FX_BOOL					IsParsered() const
+    virtual bool					ParseTextPage();
+    virtual void					NormalizeObjects(bool bNormalize);
+    virtual	bool					IsParsered() const
     {
         return m_IsParsered;
     }
@@ -71,10 +71,10 @@ public:
     virtual int						CountRects(int start, int nCount);
     virtual	void					GetRect(int rectIndex, FX_FLOAT& left, FX_FLOAT& top
                                             , FX_FLOAT& right, FX_FLOAT &bottom) const;
-    virtual FX_BOOL					GetBaselineRotate(int rectIndex, int& Rotate);
-    virtual FX_BOOL					GetBaselineRotate(const CFX_FloatRect& rect, int& Rotate);
+    virtual bool					GetBaselineRotate(int rectIndex, int& Rotate);
+    virtual bool					GetBaselineRotate(const CFX_FloatRect& rect, int& Rotate);
     virtual	int						CountBoundedSegments(FX_FLOAT left, FX_FLOAT top,
-            FX_FLOAT right, FX_FLOAT bottom, FX_BOOL bContains = FALSE);
+            FX_FLOAT right, FX_FLOAT bottom, bool bContains = false);
     virtual	void					GetBoundedSegment(int index, int& start, int& count) const;
     virtual int						GetWordBreak(int index, int direction) const;
 public:
@@ -82,20 +82,20 @@ public:
     {
         return &m_charList;
     }
-    static	FX_BOOL					IsRectIntersect(const CFX_FloatRect& rect1, const CFX_FloatRect& rect2);
-    static	FX_BOOL					IsLetter(FX_WCHAR unicode);
+    static	bool					IsRectIntersect(const CFX_FloatRect& rect1, const CFX_FloatRect& rect2);
+    static	bool					IsLetter(FX_WCHAR unicode);
 private:
-    FX_BOOL							IsHyphen(FX_WCHAR curChar);
+    bool							IsHyphen(FX_WCHAR curChar);
     bool							IsControlChar(const PAGECHAR_INFO& charInfo);
-    FX_BOOL							GetBaselineRotate(int start, int end, int& Rotate);
+    bool							GetBaselineRotate(int start, int end, int& Rotate);
     void							ProcessObject();
     void							ProcessFormObject(CPDF_FormObject*	pFormObj, const CFX_AffineMatrix& formMatrix);
     void							ProcessTextObject(PDFTEXT_Obj pObj);
     void							ProcessTextObject(CPDF_TextObject*	pTextObj, const CFX_AffineMatrix& formMatrix, FX_POSITION ObjPos);
     int								ProcessInsertObject(const CPDF_TextObject* pObj, const CFX_AffineMatrix& formMatrix);
-    FX_BOOL							GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info);
-    FX_BOOL							IsSameAsPreTextObject(CPDF_TextObject* pTextObj, FX_POSITION ObjPos);
-    FX_BOOL							IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2);
+    bool							GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info);
+    bool							IsSameAsPreTextObject(CPDF_TextObject* pTextObj, FX_POSITION ObjPos);
+    bool							IsSameTextObject(CPDF_TextObject* pTextObj1, CPDF_TextObject* pTextObj2);
     int								GetCharWidth(FX_DWORD charCode, CPDF_Font* pFont) const;
     void							CloseTempLine();
     void							OnPiece(IFX_BidiChar* pBidi, CFX_WideString& str);
@@ -109,7 +109,7 @@ private:
     int32_t	FindTextlineFlowDirection();
     void SwapTempTextBuf(int32_t iCharListStartAppend,
                          int32_t iBufStartAppend);
-    FX_BOOL IsRightToLeft(const CPDF_TextObject* pTextObj,
+    bool IsRightToLeft(const CPDF_TextObject* pTextObj,
                           const CPDF_Font* pFont,
                           int nItems) const;
 protected:
@@ -123,13 +123,13 @@ protected:
     int								m_parserflag;
     CPDF_TextObject*				m_pPreTextObj;
     CFX_AffineMatrix				m_perMatrix;
-    FX_BOOL							m_IsParsered;
+    bool							m_IsParsered;
     CFX_AffineMatrix				m_DisplayMatrix;
 
     SEGMENT_Array					m_Segment;
     CFX_RectArray					m_SelRects;
     LINEOBJ							m_LineObj;
-    FX_BOOL							m_TextlineDir;
+    bool							m_TextlineDir;
     CFX_FloatRect					m_CurlineRect;
 };
 class CPDF_TextPageFind: public IPDF_TextPageFind
@@ -138,17 +138,17 @@ public:
     CPDF_TextPageFind(const IPDF_TextPage* pTextPage);
     virtual							~CPDF_TextPageFind() {};
 public:
-    virtual	FX_BOOL					FindFirst(const CFX_WideString& findwhat, int flags, int startPos = 0);
-    virtual	FX_BOOL					FindNext();
-    virtual	FX_BOOL					FindPrev();
+    virtual	bool					FindFirst(const CFX_WideString& findwhat, int flags, int startPos = 0);
+    virtual	bool					FindNext();
+    virtual	bool					FindPrev();
 
     virtual void					GetRectArray(CFX_RectArray& rects) const;
     virtual int						GetCurOrder() const;
     virtual int						GetMatchedCount()const;
 protected:
     void							ExtractFindWhat(const CFX_WideString& findwhat);
-    FX_BOOL							IsMatchWholeWord(const CFX_WideString& csPageText, int startPos, int endPos);
-    FX_BOOL							ExtractSubString(CFX_WideString& rString, const FX_WCHAR* lpszFullString,
+    bool							IsMatchWholeWord(const CFX_WideString& csPageText, int startPos, int endPos);
+    bool							ExtractSubString(CFX_WideString& rString, const FX_WCHAR* lpszFullString,
             int iSubString, FX_WCHAR chSep);
     CFX_WideString					MakeReverse(const CFX_WideString& str);
     int								ReverseFind(const CFX_WideString& csPageText, const CFX_WideString& csWord, int nStartPos, int& WordLength);
@@ -162,12 +162,12 @@ private:
     CFX_WideStringArray				m_csFindWhatArray;
     int								m_findNextStart;
     int								m_findPreStart;
-    FX_BOOL							m_bMatchCase;
-    FX_BOOL							m_bMatchWholeWord;
+    bool							m_bMatchCase;
+    bool							m_bMatchWholeWord;
     int								m_resStart;
     int								m_resEnd;
     CFX_RectArray					m_resArray;
-    FX_BOOL							m_IsFind;
+    bool							m_IsFind;
 };
 class CPDF_LinkExt
 {
@@ -184,8 +184,8 @@ class CPDF_LinkExtract: public IPDF_LinkExtract
 public:
     CPDF_LinkExtract();
     virtual							~CPDF_LinkExtract();
-    virtual FX_BOOL					ExtractLinks(const IPDF_TextPage* pTextPage);
-    virtual	FX_BOOL					IsExtract() const
+    virtual bool					ExtractLinks(const IPDF_TextPage* pTextPage);
+    virtual	bool					IsExtract() const
     {
         return m_IsParserd;
     }
@@ -197,14 +197,14 @@ public:
 protected:
     void							parserLink();
     void							DeleteLinkList();
-    FX_BOOL							CheckWebLink(CFX_WideString& strBeCheck);
-    FX_BOOL							CheckMailLink(CFX_WideString& str);
-    FX_BOOL							AppendToLinkList(int start, int count, const CFX_WideString& strUrl);
+    bool							CheckWebLink(CFX_WideString& strBeCheck);
+    bool							CheckMailLink(CFX_WideString& str);
+    bool							AppendToLinkList(int start, int count, const CFX_WideString& strUrl);
 private:
     LINK_InfoArray					m_LinkList;
     const CPDF_TextPage*			m_pTextPage;
     CFX_WideString					m_strPageText;
-    FX_BOOL							m_IsParserd;
+    bool							m_IsParserd;
 };
 FX_STRSIZE FX_Unicode_GetNormalization(FX_WCHAR wch, FX_WCHAR* pDst);
 void NormalizeString(CFX_WideString& str);
diff --git a/core/src/fpdftext/txtproc.h b/core/src/fpdftext/txtproc.h
index 275aabd53b..efe9ff9082 100644
--- a/core/src/fpdftext/txtproc.h
+++ b/core/src/fpdftext/txtproc.h
@@ -33,8 +33,8 @@ public:
     ~CTextBaseLine();
     void	InsertTextBox(FX_FLOAT leftx, FX_FLOAT rightx, FX_FLOAT topy, FX_FLOAT bottomy,
                           FX_FLOAT spacew, FX_FLOAT fontsize_v, const CFX_WideString& str);
-    FX_BOOL	GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx);
-    FX_BOOL	CanMerge(CTextBaseLine* pOther);
+    bool	GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx);
+    bool	CanMerge(CTextBaseLine* pOther);
     void	Merge(CTextBaseLine* pOther);
     void	MergeBoxes();
     void	CountChars(int& count, FX_FLOAT& width, int& minchars);
@@ -57,9 +57,9 @@ public:
                                  FX_FLOAT rightx, FX_FLOAT topy, FX_FLOAT bottomy, FX_FLOAT spacew, FX_FLOAT fontsize_v,
                                  CFX_ByteString& str, CPDF_Font* pFont);
     void	WriteOutput(CFX_WideStringArray& lines, int iMinWidth);
-    FX_BOOL	m_bAutoWidth;
-    FX_BOOL	m_bKeepColumn;
-    FX_BOOL	m_bBreakSpace;
+    bool	m_bAutoWidth;
+    bool	m_bKeepColumn;
+    bool	m_bBreakSpace;
 
 private:
     CFX_PtrArray	m_BaseLines;
diff --git a/core/src/fxcodec/codec/codec_int.h b/core/src/fxcodec/codec/codec_int.h
index 7668f84a20..dc64748e83 100644
--- a/core/src/fxcodec/codec/codec_int.h
+++ b/core/src/fxcodec/codec/codec_int.h
@@ -17,9 +17,9 @@
 class CCodec_BasicModule : public ICodec_BasicModule
 {
 public:
-    virtual FX_BOOL	RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+    virtual bool	RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                                     FX_DWORD& dest_size);
-    virtual FX_BOOL	A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+    virtual bool	A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                               FX_DWORD& dest_size);
     virtual ICodec_ScanlineDecoder*	CreateRunLengthDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
             int nComps, int bpc);
@@ -46,7 +46,7 @@ public:
 
     uint8_t*			GetScanline(int line);
 
-    FX_BOOL				SkipToScanline(int line, IFX_Pause* pPause);
+    bool				SkipToScanline(int line, IFX_Pause* pPause);
 
     int					GetWidth()
     {
@@ -68,7 +68,7 @@ public:
         return m_bpc;
     }
 
-    FX_BOOL				IsColorTransformed()
+    bool				IsColorTransformed()
     {
         return m_bColorTransformed;
     }
@@ -98,11 +98,11 @@ protected:
 
     int					m_Pitch;
 
-    FX_BOOL				m_bColorTransformed;
+    bool				m_bColorTransformed;
 
     uint8_t*			ReadNextLine();
 
-    virtual FX_BOOL		v_Rewind() = 0;
+    virtual bool		v_Rewind() = 0;
 
     virtual uint8_t*	v_GetNextLine() = 0;
 
@@ -118,21 +118,21 @@ class CCodec_FaxModule : public ICodec_FaxModule
 {
 public:
     virtual ICodec_ScanlineDecoder*	CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-            int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows);
-    FX_BOOL		Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size);
+            int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows);
+    bool		Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size);
 };
 class CCodec_FlateModule : public ICodec_FlateModule
 {
 public:
     virtual ICodec_ScanlineDecoder*	CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
             int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns);
-    virtual FX_DWORD FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
+    virtual FX_DWORD FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, bool bEarlyChange,
                                       int predictor, int Colors, int BitsPerComponent, int Columns,
                                       FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
-    virtual FX_BOOL Encode(const uint8_t* src_buf, FX_DWORD src_size,
+    virtual bool Encode(const uint8_t* src_buf, FX_DWORD src_size,
                            int predictor, int Colors, int BitsPerComponent, int Columns,
                            uint8_t*& dest_buf, FX_DWORD& dest_size);
-    virtual FX_BOOL		Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
+    virtual bool		Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 };
 class CCodec_JpegModule : public ICodec_JpegModule
 {
@@ -143,17 +143,17 @@ public:
         m_pExtProvider = pJP;
     }
     ICodec_ScanlineDecoder*	CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size,
-                                          int width, int height, int nComps, FX_BOOL ColorTransform);
-    FX_BOOL		LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
-                         int& num_components, int& bits_per_components, FX_BOOL& color_transform,
+                                          int width, int height, int nComps, bool ColorTransform);
+    bool		LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
+                         int& num_components, int& bits_per_components, bool& color_transform,
                          uint8_t** icc_buf_ptr, FX_DWORD* icc_length);
-    FX_BOOL		Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length);
+    bool		Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length);
     virtual void*		Start();
     virtual void		Finish(void* pContext);
     virtual void		Input(void* pContext, const uint8_t* src_buf, FX_DWORD src_size);
     virtual int			ReadHeader(void* pContext, int* width, int* height, int* nComps);
     virtual int			StartScanline(void* pContext, int down_scale);
-    virtual FX_BOOL		ReadScanline(void* pContext, uint8_t* dest_buf);
+    virtual bool		ReadScanline(void* pContext, uint8_t* dest_buf);
     virtual FX_DWORD	GetAvailInput(void* pContext, uint8_t** avail_buf_ptr);
 protected:
     IFX_JpegProvider* m_pExtProvider;
@@ -199,10 +199,10 @@ class CCodec_JpxModule : public ICodec_JpxModule
 {
 public:
     CCodec_JpxModule();
-    void*		CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL useColorSpace = FALSE);
+    void*		CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, bool useColorSpace = false);
     void		GetImageInfo(void* ctx, FX_DWORD& width, FX_DWORD& height,
                              FX_DWORD& codestream_nComps, FX_DWORD& output_nComps);
-    FX_BOOL		Decode(void* ctx, uint8_t* dest_data, int pitch, FX_BOOL bTranslateColor, uint8_t* offsets);
+    bool		Decode(void* ctx, uint8_t* dest_data, int pitch, bool bTranslateColor, uint8_t* offsets);
     void		DestroyDecoder(void* ctx);
 };
 class CPDF_Jbig2Interface : public CJBig2_Module
@@ -253,7 +253,7 @@ public:
     FX_DWORD m_global_size;
     uint8_t* m_dest_buf;
     FX_DWORD m_dest_pitch;
-    FX_BOOL	m_bFileReader;
+    bool	m_bFileReader;
     IFX_Pause* m_pPause;
     CJBig2_Context* m_pContext;
     CJBig2_Image* m_dest_image;
@@ -263,9 +263,9 @@ class CCodec_Jbig2Module : public ICodec_Jbig2Module
 public:
     CCodec_Jbig2Module() {};
     ~CCodec_Jbig2Module();
-    FX_BOOL		Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
+    bool		Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
                        const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch);
-    FX_BOOL		Decode(IFX_FileRead* file_ptr,
+    bool		Decode(IFX_FileRead* file_ptr,
                        FX_DWORD& width, FX_DWORD& height, FX_DWORD& pitch, uint8_t*& dest_buf);
     void*				CreateJbig2Context();
     FXCODEC_STATUS		StartDecode(void* pJbig2Context, FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
diff --git a/core/src/fxcodec/codec/fx_codec.cpp b/core/src/fxcodec/codec/fx_codec.cpp
index 9bbcce105f..8edfde5319 100644
--- a/core/src/fxcodec/codec/fx_codec.cpp
+++ b/core/src/fxcodec/codec/fx_codec.cpp
@@ -49,13 +49,13 @@ uint8_t* CCodec_ScanlineDecoder::GetScanline(int line)
     m_NextLine ++;
     return m_pLastScanline;
 }
-FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause)
+bool CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause)
 {
     if (m_pDataCache && line < m_pDataCache->m_nCachedLines) {
-        return FALSE;
+        return false;
     }
     if (m_NextLine == line || m_NextLine == line + 1) {
-        return FALSE;
+        return false;
     }
     if (m_NextLine < 0 || m_NextLine > line) {
         v_Rewind();
@@ -66,10 +66,10 @@ FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause)
         m_pLastScanline = ReadNextLine();
         m_NextLine ++;
         if (pPause && pPause->NeedToPauseNow()) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 uint8_t* CCodec_ScanlineDecoder::ReadNextLine()
 {
@@ -107,10 +107,10 @@ void CCodec_ScanlineDecoder::DownScale(int dest_width, int dest_height)
     m_pDataCache->m_Width = m_OutputWidth;
     m_pDataCache->m_nCachedLines = 0;
 }
-FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+bool CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
         FX_DWORD& dest_size)
 {
-    return FALSE;
+    return false;
 }
 extern "C" double FXstrtod(const char* nptr, char** endptr)
 {
@@ -216,26 +216,26 @@ extern "C" double FXstrtod(const char* nptr, char** endptr)
     }
     return is_negative ? -ret : ret;
 }
-FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+bool CCodec_BasicModule::A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                                       FX_DWORD& dest_size)
 {
-    return FALSE;
+    return false;
 }
 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_RLScanlineDecoder();
     virtual ~CCodec_RLScanlineDecoder();
-    FX_BOOL				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc);
+    bool				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc);
     virtual void		v_DownScale(int dest_width, int dest_height) {}
-    virtual FX_BOOL		v_Rewind();
+    virtual bool		v_Rewind();
     virtual uint8_t*	v_GetNextLine();
     virtual FX_DWORD	GetSrcOffset()
     {
         return m_SrcOffset;
     }
 protected:
-    FX_BOOL				CheckDestSize();
+    bool				CheckDestSize();
     void				GetNextOperator();
     void				UpdateOperator(uint8_t used_bytes);
 
@@ -244,7 +244,7 @@ protected:
     FX_DWORD			m_SrcSize;
     FX_DWORD			m_dwLineBytes;
     FX_DWORD			m_SrcOffset;
-    FX_BOOL				m_bEOD;
+    bool				m_bEOD;
     uint8_t				m_Operator;
 };
 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
@@ -253,7 +253,7 @@ CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
     , m_SrcSize(0)
     , m_dwLineBytes(0)
     , m_SrcOffset(0)
-    , m_bEOD(FALSE)
+    , m_bEOD(false)
     , m_Operator(0)
 {
 }
@@ -263,7 +263,7 @@ CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder()
         FX_Free(m_pScanline);
     }
 }
-FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize()
+bool CCodec_RLScanlineDecoder::CheckDestSize()
 {
     FX_DWORD i = 0;
     FX_DWORD old_size = 0;
@@ -273,14 +273,14 @@ FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize()
             old_size = dest_size;
             dest_size += m_pSrcBuf[i] + 1;
             if (dest_size < old_size) {
-                return FALSE;
+                return false;
             }
             i += m_pSrcBuf[i] + 2;
         } else if (m_pSrcBuf[i] > 128) {
             old_size = dest_size;
             dest_size += 257 - m_pSrcBuf[i];
             if (dest_size < old_size) {
-                return FALSE;
+                return false;
             }
             i += 2;
         } else {
@@ -288,11 +288,11 @@ FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize()
         }
     }
     if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 > dest_size) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc)
+bool CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc)
 {
     m_pSrcBuf = src_buf;
     m_SrcSize = src_size;
@@ -300,20 +300,20 @@ FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_si
     m_OutputHeight = m_OrigHeight = height;
     m_nComps = nComps;
     m_bpc = bpc;
-    m_bColorTransformed = FALSE;
+    m_bColorTransformed = false;
     m_DownScale = 1;
     m_Pitch = (width * nComps * bpc + 31) / 32 * 4;
     m_dwLineBytes = (width * nComps * bpc + 7) / 8;
     m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     return CheckDestSize();
 }
-FX_BOOL CCodec_RLScanlineDecoder::v_Rewind()
+bool CCodec_RLScanlineDecoder::v_Rewind()
 {
     FXSYS_memset(m_pScanline, 0, m_Pitch);
     m_SrcOffset = 0;
-    m_bEOD = FALSE;
+    m_bEOD = false;
     m_Operator = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine()
 {
@@ -326,17 +326,17 @@ uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine()
     }
     FXSYS_memset(m_pScanline, 0, m_Pitch);
     FX_DWORD col_pos = 0;
-    FX_BOOL	eol = FALSE;
+    bool	eol = false;
     while (m_SrcOffset < m_SrcSize && !eol) {
         if (m_Operator < 128) {
             FX_DWORD copy_len = m_Operator + 1;
             if (col_pos + copy_len >= m_dwLineBytes) {
                 copy_len = m_dwLineBytes - col_pos;
-                eol = TRUE;
+                eol = true;
             }
             if (copy_len >= m_SrcSize - m_SrcOffset) {
                 copy_len = m_SrcSize - m_SrcOffset;
-                m_bEOD = TRUE;
+                m_bEOD = true;
             }
             FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
             col_pos += copy_len;
@@ -349,13 +349,13 @@ uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine()
             FX_DWORD duplicate_len = 257 - m_Operator;
             if (col_pos + duplicate_len >= m_dwLineBytes) {
                 duplicate_len = m_dwLineBytes - col_pos;
-                eol = TRUE;
+                eol = true;
             }
             FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len);
             col_pos += duplicate_len;
             UpdateOperator((uint8_t)duplicate_len);
         } else {
-            m_bEOD = TRUE;
+            m_bEOD = true;
             break;
         }
     }
diff --git a/core/src/fxcodec/codec/fx_codec_fax.cpp b/core/src/fxcodec/codec/fx_codec_fax.cpp
index d45600372f..3446d0a7b9 100644
--- a/core/src/fxcodec/codec/fx_codec_fax.cpp
+++ b/core/src/fxcodec/codec/fx_codec_fax.cpp
@@ -79,7 +79,7 @@ int _FindBit(const uint8_t* data_buf, int max_pos, int start_pos, int bit)
     }
     return pos;
 }
-void _FaxG4FindB1B2(const uint8_t* ref_buf, int columns, int a0, FX_BOOL a0color, int& b1, int& b2)
+void _FaxG4FindB1B2(const uint8_t* ref_buf, int columns, int a0, bool a0color, int& b1, int& b2)
 {
     if (a0color) {
         a0color = 1;
@@ -400,27 +400,27 @@ int _FaxGetRun(const uint8_t* ins_array, const uint8_t* src_buf, int& bitpos, in
         }
     }
 }
-FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns)
+bool _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns)
 {
     int a0 = -1, a0color = 1;
     while (1) {
         if (bitpos >= bitsize) {
-            return FALSE;
+            return false;
         }
         int a1, a2, b1, b2;
         _FaxG4FindB1B2(ref_buf, columns, a0, a0color, b1, b2);
-        FX_BOOL bit = NEXTBIT;
+        bool bit = NEXTBIT;
         int v_delta = 0;
         if (bit) {
         } else {
             if (bitpos >= bitsize) {
-                return FALSE;
+                return false;
             }
-            FX_BOOL bit1 = NEXTBIT;
+            bool bit1 = NEXTBIT;
             if (bitpos >= bitsize) {
-                return FALSE;
+                return false;
             }
-            FX_BOOL bit2 = NEXTBIT;
+            bool bit2 = NEXTBIT;
             if (bit1 && bit2) {
                 v_delta = 1;
             } else if (bit1) {
@@ -457,10 +457,10 @@ FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
                 if (a0 < columns) {
                     continue;
                 }
-                return TRUE;
+                return true;
             } else {
                 if (bitpos >= bitsize) {
-                    return FALSE;
+                    return false;
                 }
                 bit = NEXTBIT;
                 if (bit) {
@@ -468,26 +468,26 @@ FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
                         _FaxFillBits(dest_buf, columns, a0, b2);
                     }
                     if (b2 >= columns) {
-                        return TRUE;
+                        return true;
                     }
                     a0 = b2;
                     continue;
                 } else {
                     if (bitpos >= bitsize) {
-                        return FALSE;
+                        return false;
                     }
-                    FX_BOOL bit1 = NEXTBIT;
+                    bool bit1 = NEXTBIT;
                     if (bitpos >= bitsize) {
-                        return FALSE;
+                        return false;
                     }
-                    FX_BOOL bit2 = NEXTBIT;
+                    bool bit2 = NEXTBIT;
                     if (bit1 && bit2) {
                         v_delta = 2;
                     } else if (bit1) {
                         v_delta = -2;
                     } else if (bit2) {
                         if (bitpos >= bitsize) {
-                            return FALSE;
+                            return false;
                         }
                         bit = NEXTBIT;
                         if (bit) {
@@ -497,7 +497,7 @@ FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
                         }
                     } else {
                         if (bitpos >= bitsize) {
-                            return FALSE;
+                            return false;
                         }
                         bit = NEXTBIT;
                         if (bit) {
@@ -505,7 +505,7 @@ FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
                             continue;
                         } else {
                             bitpos += 5;
-                            return TRUE;
+                            return true;
                         }
                     }
                 }
@@ -516,13 +516,13 @@ FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
             _FaxFillBits(dest_buf, columns, a0, a1);
         }
         if (a1 >= columns) {
-            return TRUE;
+            return true;
         }
         a0 = a1;
         a0color = !a0color;
     }
 }
-FX_BOOL _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos)
+bool _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos)
 {
     int startbit = bitpos;
     while (bitpos < bitsize) {
@@ -531,18 +531,18 @@ FX_BOOL _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos)
             if (bitpos - startbit <= 11) {
                 bitpos = startbit;
             }
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns)
+bool _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns)
 {
-    int color = TRUE;
+    int color = true;
     int startpos = 0;
     while (1) {
         if (bitpos >= bitsize) {
-            return FALSE;
+            return false;
         }
         int run_len = 0;
         while (1) {
@@ -551,10 +551,10 @@ FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
                 while (bitpos < bitsize) {
                     int bit = NEXTBIT;
                     if (bit) {
-                        return TRUE;
+                        return true;
                     }
                 }
-                return FALSE;
+                return false;
             }
             run_len += run;
             if (run < 64) {
@@ -570,17 +570,17 @@ FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t*
         }
         color = !color;
     }
-    return TRUE;
+    return true;
 }
 class CCodec_FaxDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_FaxDecoder();
     virtual ~CCodec_FaxDecoder();
-    FX_BOOL				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-                               int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows);
+    bool				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
+                               int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows);
     virtual void		v_DownScale(int dest_width, int dest_height) {}
-    virtual FX_BOOL		v_Rewind();
+    virtual bool		v_Rewind();
     virtual uint8_t*	v_GetNextLine();
     virtual FX_DWORD	GetSrcOffset();
     int			m_Encoding, m_bEndOfLine, m_bByteAlign, m_bBlack;
@@ -604,8 +604,8 @@ CCodec_FaxDecoder::~CCodec_FaxDecoder()
         FX_Free(m_pRefBuf);
     }
 }
-FX_BOOL CCodec_FaxDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-                                  int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows)
+bool CCodec_FaxDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
+                                  int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows)
 {
     m_Encoding = K;
     m_bEndOfLine = EndOfLine;
@@ -628,14 +628,14 @@ FX_BOOL CCodec_FaxDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int
     m_SrcSize = src_size;
     m_nComps = 1;
     m_bpc = 1;
-    m_bColorTransformed = FALSE;
-    return TRUE;
+    m_bColorTransformed = false;
+    return true;
 }
-FX_BOOL CCodec_FaxDecoder::v_Rewind()
+bool CCodec_FaxDecoder::v_Rewind()
 {
     FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
     bitpos = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_FaxDecoder::v_GetNextLine()
 {
@@ -651,7 +651,7 @@ uint8_t* CCodec_FaxDecoder::v_GetNextLine()
     } else if (m_Encoding == 0) {
         _FaxGet1DLine(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_OrigWidth);
     } else {
-        FX_BOOL bNext1D = m_pSrcBuf[bitpos / 8] & (1 << (7 - bitpos % 8));
+        bool bNext1D = m_pSrcBuf[bitpos / 8] & (1 << (7 - bitpos % 8));
         bitpos ++;
         if (bNext1D) {
             _FaxGet1DLine(m_pSrcBuf, bitsize, bitpos, m_pScanlineBuf, m_OrigWidth);
@@ -669,7 +669,7 @@ uint8_t* CCodec_FaxDecoder::v_GetNextLine()
         while (m_bByteAlign && bitpos0 < bitpos1) {
             int bit = m_pSrcBuf[bitpos0 / 8] & (1 << (7 - bitpos0 % 8));
             if (bit != 0) {
-                m_bByteAlign = FALSE;
+                m_bByteAlign = false;
             } else {
                 bitpos0 ++;
             }
@@ -846,7 +846,7 @@ static void _AddBitStream(uint8_t* dest_buf, int& dest_bitpos, int data, int bit
         dest_bitpos ++;
     }
 }
-static void _FaxEncodeRun(uint8_t* dest_buf, int& dest_bitpos, int run, FX_BOOL bWhite)
+static void _FaxEncodeRun(uint8_t* dest_buf, int& dest_bitpos, int run, bool bWhite)
 {
     while (run >= 2560) {
         _AddBitStream(dest_buf, dest_bitpos, 0x1f, 12);
@@ -972,14 +972,14 @@ void CCodec_FaxEncoder::Encode(uint8_t*& dest_buf, FX_DWORD& dest_size)
     dest_size = m_DestBuf.GetSize();
     m_DestBuf.DetachBuffer();
 }
-FX_BOOL	CCodec_FaxModule::Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size)
+bool	CCodec_FaxModule::Encode(const uint8_t* src_buf, int width, int height, int pitch, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     CCodec_FaxEncoder encoder(src_buf, width, height, pitch);
     encoder.Encode(dest_buf, dest_size);
-    return TRUE;
+    return true;
 }
 ICodec_ScanlineDecoder*	CCodec_FaxModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-        int K, FX_BOOL EndOfLine, FX_BOOL EncodedByteAlign, FX_BOOL BlackIs1, int Columns, int Rows)
+        int K, bool EndOfLine, bool EncodedByteAlign, bool BlackIs1, int Columns, int Rows)
 {
     CCodec_FaxDecoder* pDecoder = new CCodec_FaxDecoder;
     pDecoder->Create(src_buf, src_size, width, height, K, EndOfLine, EncodedByteAlign, BlackIs1, Columns, Rows);
diff --git a/core/src/fxcodec/codec/fx_codec_flate.cpp b/core/src/fxcodec/codec/fx_codec_flate.cpp
index d129e36392..a61be75bbe 100644
--- a/core/src/fxcodec/codec/fx_codec_flate.cpp
+++ b/core/src/fxcodec/codec/fx_codec_flate.cpp
@@ -84,7 +84,7 @@ extern "C"
 class CLZWDecoder
 {
 public:
-    int Decode(uint8_t* output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, FX_BOOL bEarlyChange);
+    int Decode(uint8_t* output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, bool bEarlyChange);
 
 private:
     void AddCode(FX_DWORD prefix_code, uint8_t append_char);
@@ -94,7 +94,7 @@ private:
     FX_DWORD	m_OutPos;
     uint8_t*	m_pOutput;
     const uint8_t*	m_pInput;
-    FX_BOOL		m_Early;
+    bool		m_Early;
     FX_DWORD	m_CodeArray[5021];
     FX_DWORD	m_nCodes;
     uint8_t		m_DecodeStack[4000];
@@ -134,7 +134,7 @@ void CLZWDecoder::DecodeString(FX_DWORD code)
     }
     m_DecodeStack[m_StackLen++] = (uint8_t)code;
 }
-int CLZWDecoder::Decode(uint8_t* dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, FX_BOOL bEarlyChange)
+int CLZWDecoder::Decode(uint8_t* dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, bool bEarlyChange)
 {
     m_CodeLen = 9;
     m_InPos = 0;
@@ -238,14 +238,14 @@ static uint8_t PaethPredictor(int a, int b, int c)
     }
     return (uint8_t)c;
 }
-static FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
                                    int predictor, int Colors,
                                    int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count);
@@ -328,7 +328,7 @@ static FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = (row_size + 1) * row_count - (last_row_size > 0 ? (row_size - last_row_size) : 0);
-    return TRUE;
+    return true;
 }
 static void PNG_PredictLine(uint8_t* pDestData, const uint8_t* pSrcData, const uint8_t* pLastLine,
                             int bpc, int nColors, int nPixels)
@@ -393,13 +393,13 @@ static void PNG_PredictLine(uint8_t* pDestData, const uint8_t* pSrcData, const u
         }
     }
 }
-static FX_BOOL PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
                              int Colors, int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size) / (row_size + 1);
     const int last_row_size = data_size % (row_size + 1);
     uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
@@ -479,7 +479,7 @@ static FX_BOOL PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = row_size * row_count - (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0);
-    return TRUE;
+    return true;
 }
 static void TIFF_PredictorEncodeLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns)
 {
@@ -518,12 +518,12 @@ static void TIFF_PredictorEncodeLine(uint8_t* dest_buf, int row_size, int BitsPe
         }
     }
 }
-static FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
                                     int Colors, int BitsPerComponent, int Columns)
 {
     int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size == 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     for (int row = 0; row < row_count; row++) {
@@ -533,7 +533,7 @@ static FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
         }
         TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
     }
-    return TRUE;
+    return true;
 }
 static void TIFF_PredictLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns)
 {
@@ -568,12 +568,12 @@ static void TIFF_PredictLine(uint8_t* dest_buf, int row_size, int BitsPerCompone
         }
     }
 }
-static FX_BOOL TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
                               int Colors, int BitsPerComponent, int Columns)
 {
     int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size == 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     for (int row = 0; row < row_count; row ++) {
@@ -583,7 +583,7 @@ static FX_BOOL TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
         }
         TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
     }
-    return TRUE;
+    return true;
 }
 class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder
 {
@@ -597,7 +597,7 @@ public:
         delete this;
     }
     virtual void		v_DownScale(int dest_width, int dest_height) {}
-    virtual FX_BOOL		v_Rewind();
+    virtual bool		v_Rewind();
     virtual uint8_t*	v_GetNextLine();
     virtual FX_DWORD	GetSrcOffset();
     void*				m_pFlate;
@@ -646,7 +646,7 @@ void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_si
     m_OutputHeight = m_OrigHeight = height;
     m_nComps = nComps;
     m_bpc = bpc;
-    m_bColorTransformed = FALSE;
+    m_bColorTransformed = false;
     m_Pitch = (width * nComps * bpc + 7) / 8;
     m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     m_Predictor = 0;
@@ -672,18 +672,18 @@ void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_si
         }
     }
 }
-FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind()
+bool CCodec_FlateScanlineDecoder::v_Rewind()
 {
     if (m_pFlate) {
         FPDFAPI_FlateEnd(m_pFlate);
     }
     m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (m_pFlate == NULL) {
-        return FALSE;
+        return false;
     }
     FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize);
     m_LeftOver = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine()
 {
@@ -732,7 +732,7 @@ FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset()
 static void FlateUncompress(const uint8_t* src_buf, FX_DWORD src_size, FX_DWORD orig_size,
                             uint8_t*& dest_buf, FX_DWORD& dest_size, FX_DWORD& offset)
 {
-    const FX_BOOL useOldImpl = src_size < 10240;
+    const bool useOldImpl = src_size < 10240;
     FX_DWORD guess_size = orig_size ? orig_size : src_size * 2;
     FX_DWORD alloc_step = orig_size ? 10240 : (src_size < 10240 ? 10240 : src_size);
     static const FX_DWORD kMaxInitialAllocSize = 10000000;
@@ -839,7 +839,7 @@ ICodec_ScanlineDecoder*	CCodec_FlateModule::CreateDecoder(const uint8_t* src_buf
     pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
     return pDecoder;
 }
-FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
+FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, bool bEarlyChange,
         int predictor, int Colors, int BitsPerComponent, int Columns,
         FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
@@ -876,7 +876,7 @@ FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_b
     if (predictor_type == 0) {
         return offset;
     }
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if (predictor_type == 2) {
         ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                             Columns);
@@ -886,7 +886,7 @@ FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_b
     }
     return ret ? offset : -1;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
                                    int predictor, int Colors, int BitsPerComponent, int Columns,
                                    uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
@@ -896,7 +896,7 @@ FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
     uint8_t* pSrcBuf = NULL;
     pSrcBuf = FX_Alloc(uint8_t, src_size);
     FXSYS_memcpy(pSrcBuf, src_buf, src_size);
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if (predictor == 2) {
         ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                    Columns);
@@ -909,12 +909,12 @@ FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
     FX_Free(pSrcBuf);
     return ret;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     dest_size = src_size + src_size / 1000 + 12;
     dest_buf = FX_Alloc( uint8_t, dest_size);
     unsigned long temp_size = dest_size;
     FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
     dest_size = (FX_DWORD)temp_size;
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fxcodec/codec/fx_codec_icc.cpp b/core/src/fxcodec/codec/fx_codec_icc.cpp
index 7507fe5d6d..0ccfe1fba6 100644
--- a/core/src/fxcodec/codec/fx_codec_icc.cpp
+++ b/core/src/fxcodec/codec/fx_codec_icc.cpp
@@ -14,7 +14,7 @@ const FX_DWORD N_COMPONENT_RGB = 3;
 const FX_DWORD N_COMPONENT_CMYK = 4;
 const FX_DWORD N_COMPONENT_DEFAULT = 3;
 
-FX_BOOL MD5ComputeID( const void* buf, FX_DWORD dwSize, uint8_t ID[16] )
+bool MD5ComputeID( const void* buf, FX_DWORD dwSize, uint8_t ID[16] )
 {
     return cmsMD5computeIDExt(buf, dwSize, ID);
 }
@@ -22,50 +22,50 @@ struct CLcmsCmm  {
     cmsHTRANSFORM m_hTransform;
     int			m_nSrcComponents;
     int			m_nDstComponents;
-    FX_BOOL		m_bLab;
+    bool		m_bLab;
 };
 extern "C" {
     int ourHandler(int ErrorCode, const char *ErrorText)
     {
-        return TRUE;
+        return true;
     }
 };
-FX_BOOL CheckComponents(cmsColorSpaceSignature cs, int nComponents, FX_BOOL bDst)
+bool CheckComponents(cmsColorSpaceSignature cs, int nComponents, bool bDst)
 {
     if (nComponents <= 0 || nComponents > 15) {
-        return FALSE;
+        return false;
     }
     switch(cs) {
         case cmsSigLabData:
             if (nComponents < 3) {
-                return FALSE;
+                return false;
             }
             break;
         case cmsSigGrayData:
             if (bDst && nComponents != 1) {
-                return FALSE;
+                return false;
             }
             if (!bDst && nComponents > 2) {
-                return FALSE;
+                return false;
             }
             break;
         case cmsSigRgbData:
             if (bDst && nComponents != 3) {
-                return FALSE;
+                return false;
             }
             break;
         case cmsSigCmykData:
             if (bDst && nComponents != 4) {
-                return FALSE;
+                return false;
             }
             break;
         default:
             if (nComponents != 3) {
-                return FALSE;
+                return false;
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 int32_t GetCSComponents(cmsColorSpaceSignature cs)
 {
@@ -112,12 +112,12 @@ void* IccLib_CreateTransform(const unsigned char* pSrcProfileData, FX_DWORD dwSr
         return NULL;
     }
     int srcFormat;
-    FX_BOOL bLab = FALSE;
+    bool bLab = false;
     cmsColorSpaceSignature srcCS = cmsGetColorSpace(srcProfile);
     nSrcComponents = GetCSComponents(srcCS);
     if (srcCS == cmsSigLabData) {
         srcFormat = COLORSPACE_SH(PT_Lab) | CHANNELS_SH(nSrcComponents) | BYTES_SH(0);
-        bLab = TRUE;
+        bLab = true;
     } else {
         srcFormat = COLORSPACE_SH(PT_ANY) | CHANNELS_SH(nSrcComponents) | BYTES_SH(1);
         if (srcCS == cmsSigRgbData && T_DOSWAP(dwSrcFormat)) {
@@ -125,7 +125,7 @@ void* IccLib_CreateTransform(const unsigned char* pSrcProfileData, FX_DWORD dwSr
         }
     }
     cmsColorSpaceSignature dstCS = cmsGetColorSpace(dstProfile);
-    if (!CheckComponents(dstCS, nDstComponents, TRUE)) {
+    if (!CheckComponents(dstCS, nDstComponents, true)) {
         cmsCloseProfile(srcProfile);
         cmsCloseProfile(dstProfile);
         return NULL;
diff --git a/core/src/fxcodec/codec/fx_codec_jbig.cpp b/core/src/fxcodec/codec/fx_codec_jbig.cpp
index 51184306eb..c13a2f9526 100644
--- a/core/src/fxcodec/codec/fx_codec_jbig.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jbig.cpp
@@ -26,28 +26,28 @@ void CCodec_Jbig2Module::DestroyJbig2Context(void* pJbig2Content)
     }
     pJbig2Content = NULL;
 }
-FX_BOOL CCodec_Jbig2Module::Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
+bool CCodec_Jbig2Module::Decode(FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
                                    const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch)
 {
     FXSYS_memset(dest_buf, 0, height * dest_pitch);
     CJBig2_Context* pContext = CJBig2_Context::CreateContext(&m_Module,
                                (uint8_t*)global_data, global_size, (uint8_t*)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache);
     if (pContext == NULL) {
-        return FALSE;
+        return false;
     }
     int ret = pContext->getFirstPage(dest_buf, width, height, dest_pitch, NULL);
     CJBig2_Context::DestroyContext(pContext);
     if (ret != JBIG2_SUCCESS) {
-        return FALSE;
+        return false;
     }
     int dword_size = height * dest_pitch / 4;
     FX_DWORD* dword_buf = (FX_DWORD*)dest_buf;
     for (int i = 0; i < dword_size; i ++) {
         dword_buf[i] = ~dword_buf[i];
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CCodec_Jbig2Module::Decode(IFX_FileRead* file_ptr,
+bool CCodec_Jbig2Module::Decode(IFX_FileRead* file_ptr,
                                    FX_DWORD& width, FX_DWORD& height, FX_DWORD& pitch, uint8_t*& dest_buf)
 {
     CJBig2_Context* pContext = NULL;
@@ -71,15 +71,15 @@ FX_BOOL CCodec_Jbig2Module::Decode(IFX_FileRead* file_ptr,
     height = (FX_DWORD)dest_image->m_nHeight;
     pitch = (FX_DWORD)dest_image->m_nStride;
     dest_buf = dest_image->m_pData;
-    dest_image->m_bNeedFree = FALSE;
+    dest_image->m_bNeedFree = false;
     delete dest_image;
     FX_Free(src_buf);
-    return TRUE;
+    return true;
 failed:
     if(src_buf) {
         FX_Free(src_buf);
     }
-    return FALSE;
+    return false;
 }
 FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, FX_DWORD width, FX_DWORD height, const uint8_t* src_buf, FX_DWORD src_size,
         const uint8_t* global_data, FX_DWORD global_size, uint8_t* dest_buf, FX_DWORD dest_pitch, IFX_Pause* pPause)
@@ -97,7 +97,7 @@ FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, FX_DWORD wid
     m_pJbig2Context->m_dest_buf = dest_buf;
     m_pJbig2Context->m_dest_pitch = dest_pitch;
     m_pJbig2Context->m_pPause = pPause;
-    m_pJbig2Context->m_bFileReader = FALSE;
+    m_pJbig2Context->m_bFileReader = false;
     FXSYS_memset(dest_buf, 0, height * dest_pitch);
     m_pJbig2Context->m_pContext = CJBig2_Context::CreateContext(&m_Module,
                                   (uint8_t*)global_data, global_size, (uint8_t*)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache, pPause);
@@ -127,7 +127,7 @@ FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, IFX_FileRead
         return FXCODEC_STATUS_ERR_PARAMS;
     }
     CCodec_Jbig2Context* m_pJbig2Context = (CCodec_Jbig2Context*)pJbig2Context;
-    m_pJbig2Context->m_bFileReader = TRUE;
+    m_pJbig2Context->m_bFileReader = true;
     m_pJbig2Context->m_dest_image = NULL;
     m_pJbig2Context->m_src_size = (FX_DWORD)file_ptr->GetSize();
     m_pJbig2Context->m_src_buf = FX_Alloc(uint8_t, m_pJbig2Context->m_src_size);
@@ -145,7 +145,7 @@ FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, IFX_FileRead
         height = (FX_DWORD)m_pJbig2Context->m_dest_image->m_nHeight;
         pitch = (FX_DWORD)m_pJbig2Context->m_dest_image->m_nStride;
         dest_buf = m_pJbig2Context->m_dest_image->m_pData;
-        m_pJbig2Context->m_dest_image->m_bNeedFree = FALSE;
+        m_pJbig2Context->m_dest_image->m_bNeedFree = false;
         return FXCODEC_STATUS_DECODE_TOBECONTINUE;
     }
     CJBig2_Context::DestroyContext(m_pJbig2Context->m_pContext);
@@ -157,7 +157,7 @@ FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, IFX_FileRead
     height = (FX_DWORD)m_pJbig2Context->m_dest_image->m_nHeight;
     pitch = (FX_DWORD)m_pJbig2Context->m_dest_image->m_nStride;
     dest_buf = m_pJbig2Context->m_dest_image->m_pData;
-    m_pJbig2Context->m_dest_image->m_bNeedFree = FALSE;
+    m_pJbig2Context->m_dest_image->m_bNeedFree = false;
     delete m_pJbig2Context->m_dest_image;
     FX_Free(m_pJbig2Context->m_src_buf);
     return FXCODEC_STATUS_DECODE_FINISH;
diff --git a/core/src/fxcodec/codec/fx_codec_jpeg.cpp b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
index 6839d31509..1ac2f03c04 100644
--- a/core/src/fxcodec/codec/fx_codec_jpeg.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jpeg.cpp
@@ -78,15 +78,15 @@ extern "C" {
 #define	JPEG_MARKER_AUTHORTIME	(JPEG_APP0 + 3)
 #define	JPEG_MARKER_MAXSIZE	0xFFFF
 #define	JPEG_OVERHEAD_LEN	14
-static	FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo, const uint8_t* icc_buf_ptr, FX_DWORD icc_length)
+static	bool _JpegEmbedIccProfile(j_compress_ptr cinfo, const uint8_t* icc_buf_ptr, FX_DWORD icc_length)
 {
     if(icc_buf_ptr == NULL || icc_length == 0) {
-        return FALSE;
+        return false;
     }
     FX_DWORD icc_segment_size = (JPEG_MARKER_MAXSIZE - 2 - JPEG_OVERHEAD_LEN);
     FX_DWORD icc_segment_num = (icc_length / icc_segment_size) + 1;
     if (icc_segment_num > 255)	{
-        return FALSE;
+        return false;
     }
     FX_DWORD icc_data_length = JPEG_OVERHEAD_LEN + (icc_segment_num > 1 ? icc_segment_size : icc_length);
     uint8_t* icc_data = FX_Alloc(uint8_t, icc_data_length);
@@ -102,7 +102,7 @@ static	FX_BOOL _JpegEmbedIccProfile(j_compress_ptr cinfo, const uint8_t* icc_buf
     FXSYS_memcpy(icc_data + JPEG_OVERHEAD_LEN, icc_buf_ptr + icc_size, icc_length - icc_size);
     jpeg_write_marker(cinfo, JPEG_MARKER_ICC, icc_data, JPEG_OVERHEAD_LEN + icc_length - icc_size);
     FX_Free(icc_data);
-    return TRUE;
+    return true;
 }
 extern "C" {
     static void _dest_do_nothing(j_compress_ptr cinfo) {}
@@ -110,7 +110,7 @@ extern "C" {
 extern "C" {
     static boolean _dest_empty(j_compress_ptr cinfo)
     {
-        return FALSE;
+        return false;
     }
 };
 #define	JPEG_BLOCK_SIZE	1048576
@@ -178,9 +178,9 @@ static void _JpegEncode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STR
     }
     jpeg_set_defaults(&cinfo);
     if(quality != 75) {
-        jpeg_set_quality(&cinfo, quality, TRUE);
+        jpeg_set_quality(&cinfo, quality, true);
     }
-    jpeg_start_compress(&cinfo, TRUE);
+    jpeg_start_compress(&cinfo, true);
     _JpegEmbedIccProfile(&cinfo, icc_buf, icc_length);
     JSAMPROW row_pointer[1];
     JDIMENSION row;
@@ -221,8 +221,8 @@ static void _JpegEncode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STR
     }
     dest_size = dest_buf_length - (FX_STRSIZE)dest.free_in_buffer;
 }
-static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
-                             int& num_components, int& bits_per_components, FX_BOOL& color_transform,
+static bool _JpegLoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
+                             int& num_components, int& bits_per_components, bool& color_transform,
                              uint8_t** icc_buf_ptr, FX_DWORD* icc_length)
 {
     _JpegScanSOI(src_buf, src_size);
@@ -238,7 +238,7 @@ static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& wid
     jmp_buf mark;
     cinfo.client_data = &mark;
     if (setjmp(mark) == -1) {
-        return FALSE;
+        return false;
     }
     jpeg_create_decompress(&cinfo);
     struct jpeg_source_mgr src;
@@ -252,15 +252,15 @@ static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& wid
     cinfo.src = &src;
     if (setjmp(mark) == -1) {
         jpeg_destroy_decompress(&cinfo);
-        return FALSE;
+        return false;
     }
     if(icc_buf_ptr && icc_length) {
         jpeg_save_markers(&cinfo, JPEG_MARKER_ICC, JPEG_MARKER_MAXSIZE);
     }
-    int ret = jpeg_read_header(&cinfo, TRUE);
+    int ret = jpeg_read_header(&cinfo, true);
     if (ret != JPEG_HEADER_OK) {
         jpeg_destroy_decompress(&cinfo);
-        return FALSE;
+        return false;
     }
     width = cinfo.image_width;
     height = cinfo.image_height;
@@ -274,21 +274,21 @@ static FX_BOOL _JpegLoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& wid
         *icc_length = 0;
     }
     jpeg_destroy_decompress(&cinfo);
-    return TRUE;
+    return true;
 }
 class CCodec_JpegDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_JpegDecoder();
     ~CCodec_JpegDecoder();
-    FX_BOOL				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps,
-                               FX_BOOL ColorTransform, IFX_JpegProvider* pJP);
+    bool				Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps,
+                               bool ColorTransform, IFX_JpegProvider* pJP);
     virtual void		Destroy()
     {
         delete this;
     }
     virtual void		v_DownScale(int dest_width, int dest_height);
-    virtual FX_BOOL		v_Rewind();
+    virtual bool		v_Rewind();
     virtual uint8_t*	v_GetNextLine();
     virtual FX_DWORD	GetSrcOffset();
     jmp_buf		m_JmpBuf;
@@ -298,8 +298,8 @@ public:
     const uint8_t*	m_SrcBuf;
     FX_DWORD	m_SrcSize;
     uint8_t*	m_pScanlineBuf;
-    FX_BOOL		InitDecode();
-    FX_BOOL		m_bInited, m_bStarted, m_bJpegTransform;
+    bool		InitDecode();
+    bool		m_bInited, m_bStarted, m_bJpegTransform;
 protected:
     IFX_JpegProvider*	m_pExtProvider;
     void*				m_pExtContext;
@@ -309,8 +309,8 @@ CCodec_JpegDecoder::CCodec_JpegDecoder()
 {
     m_pScanlineBuf = NULL;
     m_DownScale = 1;
-    m_bStarted = FALSE;
-    m_bInited = FALSE;
+    m_bStarted = false;
+    m_bInited = false;
     m_pExtProvider = NULL;
     m_pExtContext = NULL;
     FXSYS_memset(&cinfo, 0, sizeof(cinfo));
@@ -331,31 +331,31 @@ CCodec_JpegDecoder::~CCodec_JpegDecoder()
         jpeg_destroy_decompress(&cinfo);
     }
 }
-FX_BOOL CCodec_JpegDecoder::InitDecode()
+bool CCodec_JpegDecoder::InitDecode()
 {
     cinfo.err = &jerr;
     cinfo.client_data = &m_JmpBuf;
     if (setjmp(m_JmpBuf) == -1) {
-        return FALSE;
+        return false;
     }
     jpeg_create_decompress(&cinfo);
-    m_bInited = TRUE;
+    m_bInited = true;
     cinfo.src = &src;
     src.bytes_in_buffer = m_SrcSize;
     src.next_input_byte = m_SrcBuf;
     if (setjmp(m_JmpBuf) == -1) {
         jpeg_destroy_decompress(&cinfo);
-        m_bInited = FALSE;
-        return FALSE;
+        m_bInited = false;
+        return false;
     }
     cinfo.image_width = m_OrigWidth;
     cinfo.image_height = m_OrigHeight;
-    int ret = jpeg_read_header(&cinfo, TRUE);
+    int ret = jpeg_read_header(&cinfo, true);
     if (ret != JPEG_HEADER_OK) {
-        return FALSE;
+        return false;
     }
     if (cinfo.saw_Adobe_marker) {
-        m_bJpegTransform = TRUE;
+        m_bJpegTransform = true;
     }
     if (cinfo.num_components == 3 && !m_bJpegTransform) {
         cinfo.out_color_space = cinfo.jpeg_color_space;
@@ -365,10 +365,10 @@ FX_BOOL CCodec_JpegDecoder::InitDecode()
     m_OutputWidth = m_OrigWidth;
     m_OutputHeight = m_OrigHeight;
     m_nDefaultScaleDenom = cinfo.scale_denom;
-    return TRUE;
+    return true;
 }
-FX_BOOL CCodec_JpegDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
-                                   int nComps, FX_BOOL ColorTransform, IFX_JpegProvider* pJP)
+bool CCodec_JpegDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
+                                   int nComps, bool ColorTransform, IFX_JpegProvider* pJP)
 {
     if (pJP) {
         m_pExtProvider = pJP;
@@ -396,21 +396,21 @@ FX_BOOL CCodec_JpegDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, in
     m_OutputWidth = m_OrigWidth = width;
     m_OutputHeight = m_OrigHeight = height;
     if (!InitDecode()) {
-        return FALSE;
+        return false;
     }
     if (cinfo.num_components < nComps) {
-        return FALSE;
+        return false;
     }
     if ((int)cinfo.image_width < width) {
-        return FALSE;
+        return false;
     }
     m_Pitch = (cinfo.image_width * cinfo.num_components + 3) / 4 * 4;
     m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
     m_nComps = cinfo.num_components;
     m_bpc = 8;
-    m_bColorTransformed = FALSE;
-    m_bStarted = FALSE;
-    return TRUE;
+    m_bColorTransformed = false;
+    m_bStarted = false;
+    return true;
 }
 extern "C" {
     int32_t FX_GetDownsampleRatio(int32_t originWidth, int32_t originHeight, int32_t downsampleWidth, int32_t downsampleHeight)
@@ -445,7 +445,7 @@ void CCodec_JpegDecoder::v_DownScale(int dest_width, int dest_height)
         m_NextLine = -1;
     }
 }
-FX_BOOL CCodec_JpegDecoder::v_Rewind()
+bool CCodec_JpegDecoder::v_Rewind()
 {
     if (m_pExtProvider) {
         return m_pExtProvider->Rewind(m_pExtContext);
@@ -453,25 +453,25 @@ FX_BOOL CCodec_JpegDecoder::v_Rewind()
     if (m_bStarted) {
         jpeg_destroy_decompress(&cinfo);
         if (!InitDecode()) {
-            return FALSE;
+            return false;
         }
     }
     if (setjmp(m_JmpBuf) == -1) {
-        return FALSE;
+        return false;
     }
     cinfo.scale_denom = m_nDefaultScaleDenom * m_DownScale;
     m_OutputWidth = (m_OrigWidth + m_DownScale - 1) / m_DownScale;
     m_OutputHeight = (m_OrigHeight + m_DownScale - 1) / m_DownScale;
     if (!jpeg_start_decompress(&cinfo)) {
         jpeg_destroy_decompress(&cinfo);
-        return FALSE;
+        return false;
     }
     if ((int)cinfo.output_width > m_OrigWidth) {
-        FXSYS_assert(FALSE);
-        return FALSE;
+        FXSYS_assert(false);
+        return false;
     }
-    m_bStarted = TRUE;
-    return TRUE;
+    m_bStarted = true;
+    return true;
 }
 uint8_t* CCodec_JpegDecoder::v_GetNextLine()
 {
@@ -492,7 +492,7 @@ FX_DWORD CCodec_JpegDecoder::GetSrcOffset()
     return (FX_DWORD)(m_SrcSize - src.bytes_in_buffer);
 }
 ICodec_ScanlineDecoder*	CCodec_JpegModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size,
-        int width, int height, int nComps, FX_BOOL ColorTransform)
+        int width, int height, int nComps, bool ColorTransform)
 {
     if (src_buf == NULL || src_size == 0) {
         return NULL;
@@ -504,8 +504,8 @@ ICodec_ScanlineDecoder*	CCodec_JpegModule::CreateDecoder(const uint8_t* src_buf,
     }
     return pDecoder;
 }
-FX_BOOL CCodec_JpegModule::LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
-                                    int& num_components, int& bits_per_components, FX_BOOL& color_transform,
+bool CCodec_JpegModule::LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, int& width, int& height,
+                                    int& num_components, int& bits_per_components, bool& color_transform,
                                     uint8_t** icc_buf_ptr, FX_DWORD* icc_length)
 {
     if (m_pExtProvider) {
@@ -515,17 +515,17 @@ FX_BOOL CCodec_JpegModule::LoadInfo(const uint8_t* src_buf, FX_DWORD src_size, i
     }
     return _JpegLoadInfo(src_buf, src_size, width, height, num_components, bits_per_components, color_transform, icc_buf_ptr, icc_length);
 }
-FX_BOOL CCodec_JpegModule::Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length)
+bool CCodec_JpegModule::Encode(const CFX_DIBSource* pSource, uint8_t*& dest_buf, FX_STRSIZE& dest_size, int quality, const uint8_t* icc_buf, FX_DWORD icc_length)
 {
     if (m_pExtProvider) {
         return m_pExtProvider->Encode(pSource, dest_buf, dest_size, quality, icc_buf, icc_length);
     }
     if(pSource->GetBPP() < 8 || pSource->GetPalette() != NULL) {
         ASSERT(pSource->GetBPP() >= 8 && pSource->GetPalette() == NULL);
-        return FALSE;
+        return false;
     }
     _JpegEncode(pSource, dest_buf, dest_size, quality, icc_buf, icc_length);
-    return TRUE;
+    return true;
 }
 struct FXJPEG_Context {
     jmp_buf			m_JumpMark;
@@ -653,14 +653,14 @@ int CCodec_JpegModule::StartScanline(void* pContext, int down_scale)
     p->m_Info.scale_denom = down_scale;
     return jpeg_start_decompress(&p->m_Info);
 }
-FX_BOOL CCodec_JpegModule::ReadScanline(void* pContext, unsigned char* dest_buf)
+bool CCodec_JpegModule::ReadScanline(void* pContext, unsigned char* dest_buf)
 {
     if (m_pExtProvider) {
         return m_pExtProvider->ReadScanline(pContext, dest_buf);
     }
     FXJPEG_Context* p = (FXJPEG_Context*)pContext;
     if (setjmp(p->m_JumpMark) == -1) {
-        return FALSE;
+        return false;
     }
     int nlines = jpeg_read_scanlines(&p->m_Info, &dest_buf, 1);
     return nlines == 1;
diff --git a/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp b/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
index 2d395b0b4b..92af626f25 100644
--- a/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
+++ b/core/src/fxcodec/codec/fx_codec_jpx_opj.cpp
@@ -587,17 +587,17 @@ class CJPX_Decoder
 public:
     CJPX_Decoder();
     ~CJPX_Decoder();
-    FX_BOOL	Init(const unsigned char* src_data, int src_size);
+    bool	Init(const unsigned char* src_data, int src_size);
     void	GetInfo(FX_DWORD& width, FX_DWORD& height, FX_DWORD& codestream_nComps, FX_DWORD& output_nComps);
-    FX_BOOL	Decode(uint8_t* dest_buf, int pitch, FX_BOOL bTranslateColor, uint8_t* offsets);
+    bool	Decode(uint8_t* dest_buf, int pitch, bool bTranslateColor, uint8_t* offsets);
     const uint8_t* m_SrcData;
     int m_SrcSize;
     opj_image_t *image;
     opj_codec_t* l_codec;
     opj_stream_t *l_stream;
-    FX_BOOL m_useColorSpace;
+    bool m_useColorSpace;
 };
-CJPX_Decoder::CJPX_Decoder(): image(NULL), l_codec(NULL), l_stream(NULL), m_useColorSpace(FALSE)
+CJPX_Decoder::CJPX_Decoder(): image(NULL), l_codec(NULL), l_stream(NULL), m_useColorSpace(false)
 {
 }
 CJPX_Decoder::~CJPX_Decoder()
@@ -612,11 +612,11 @@ CJPX_Decoder::~CJPX_Decoder()
         opj_image_destroy(image);
     }
 }
-FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, int src_size)
+bool CJPX_Decoder::Init(const unsigned char* src_data, int src_size)
 {
     static const unsigned char szJP2Header[] = { 0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a };
     if (!src_data || src_size < sizeof(szJP2Header)) {
-        return FALSE;
+        return false;
     }
     image = NULL;
     m_SrcData = src_data;
@@ -624,7 +624,7 @@ FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, int src_size)
     DecodeData srcData(const_cast<unsigned char*>(src_data), src_size);
     l_stream = fx_opj_stream_create_memory_stream(&srcData, OPJ_J2K_STREAM_CHUNK_SIZE, 1);
     if (l_stream == NULL) {
-        return FALSE;
+        return false;
     }
     opj_dparameters_t parameters;
     opj_set_default_decoder_parameters(&parameters);
@@ -637,33 +637,33 @@ FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, int src_size)
         l_codec = opj_create_decompress(OPJ_CODEC_J2K);
     }
     if(!l_codec) {
-        return FALSE;
+        return false;
     }
     opj_set_info_handler(l_codec, fx_info_callback, 00);
     opj_set_warning_handler(l_codec, fx_warning_callback, 00);
     opj_set_error_handler(l_codec, fx_error_callback, 00);
     if ( !opj_setup_decoder(l_codec, &parameters) ) {
-        return FALSE;
+        return false;
     }
     if(! opj_read_header(l_stream, l_codec, &image)) {
         image = NULL;
-        return FALSE;
+        return false;
     }
     if (!parameters.nb_tile_to_decode) {
         if (!opj_set_decode_area(l_codec, image, parameters.DA_x0,
                                     parameters.DA_y0, parameters.DA_x1, parameters.DA_y1)) {
             opj_image_destroy(image);
             image = NULL;
-            return FALSE;
+            return false;
         }
         if (!(opj_decode(l_codec, l_stream, image) && opj_end_decompress(l_codec, l_stream))) {
             opj_image_destroy(image);
             image = NULL;
-            return FALSE;
+            return false;
         }
     } else {
         if (!opj_get_decoded_tile(l_codec, l_stream, image, parameters.tile_index)) {
-            return FALSE;
+            return false;
         }
     }
     opj_stream_destroy(l_stream);
@@ -684,9 +684,9 @@ FX_BOOL CJPX_Decoder::Init(const unsigned char* src_data, int src_size)
         image->icc_profile_len = 0;
     }
     if(!image) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
 void CJPX_Decoder::GetInfo(FX_DWORD& width, FX_DWORD& height, FX_DWORD& codestream_nComps, FX_DWORD& output_nComps)
 {
@@ -694,7 +694,7 @@ void CJPX_Decoder::GetInfo(FX_DWORD& width, FX_DWORD& height, FX_DWORD& codestre
     height = (FX_DWORD)image->y1;
     output_nComps = codestream_nComps = (FX_DWORD)image->numcomps;
 }
-FX_BOOL CJPX_Decoder::Decode(uint8_t* dest_buf, int pitch, FX_BOOL bTranslateColor, uint8_t* offsets)
+bool CJPX_Decoder::Decode(uint8_t* dest_buf, int pitch, bool bTranslateColor, uint8_t* offsets)
 {
     int i, wid, hei, row, col, channel, src;
     uint8_t* pChannel;
@@ -702,14 +702,14 @@ FX_BOOL CJPX_Decoder::Decode(uint8_t* dest_buf, int pitch, FX_BOOL bTranslateCol
     uint8_t* pPixel;
 
     if(image->comps[0].w != image->x1 || image->comps[0].h != image->y1) {
-        return FALSE;
+        return false;
     }
     if(pitch < (int)(image->comps[0].w * 8 * image->numcomps + 31) >> 5 << 2) {
-        return FALSE;
+        return false;
     }
     FXSYS_memset(dest_buf, 0xff, image->y1 * pitch);
     uint8_t** channel_bufs = FX_Alloc(uint8_t*, image->numcomps);
-    FX_BOOL result = FALSE;
+    bool result = false;
     int* adjust_comps = FX_Alloc(int, image->numcomps);
     for (i = 0; i < (int)image->numcomps; i ++) {
         channel_bufs[i] = dest_buf + offsets[i];
@@ -765,7 +765,7 @@ FX_BOOL CJPX_Decoder::Decode(uint8_t* dest_buf, int pitch, FX_BOOL bTranslateCol
             }
         }
     }
-    result = TRUE;
+    result = true;
 
 done:
     FX_Free(channel_bufs);
@@ -778,7 +778,7 @@ void initialize_sign_lut();
 CCodec_JpxModule::CCodec_JpxModule()
 {
 }
-void* CCodec_JpxModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size , FX_BOOL useColorSpace)
+void* CCodec_JpxModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size , bool useColorSpace)
 {
     CJPX_Decoder* pDecoder = new CJPX_Decoder;
     pDecoder->m_useColorSpace = useColorSpace;
@@ -794,7 +794,7 @@ void CCodec_JpxModule::GetImageInfo(void* ctx, FX_DWORD& width, FX_DWORD& height
     CJPX_Decoder* pDecoder = (CJPX_Decoder*)ctx;
     pDecoder->GetInfo(width, height, codestream_nComps, output_nComps);
 }
-FX_BOOL CCodec_JpxModule::Decode(void* ctx, uint8_t* dest_data, int pitch, FX_BOOL bTranslateColor, uint8_t* offsets)
+bool CCodec_JpxModule::Decode(void* ctx, uint8_t* dest_data, int pitch, bool bTranslateColor, uint8_t* offsets)
 {
     CJPX_Decoder* pDecoder = (CJPX_Decoder*)ctx;
     return pDecoder->Decode(dest_data, pitch, bTranslateColor, offsets);
diff --git a/core/src/fxcodec/jbig2/JBig2_BitStream.h b/core/src/fxcodec/jbig2/JBig2_BitStream.h
index ff0b9fcfeb..fcd11f4ddf 100644
--- a/core/src/fxcodec/jbig2/JBig2_BitStream.h
+++ b/core/src/fxcodec/jbig2/JBig2_BitStream.h
@@ -23,7 +23,7 @@ public:
 
     int32_t read1Bit(FX_DWORD *dwResult);
 
-    int32_t read1Bit(FX_BOOL  *bResult);
+    int32_t read1Bit(bool  *bResult);
 
     int32_t read1Byte(uint8_t *cResult);
 
@@ -165,7 +165,7 @@ inline int32_t CJBig2_BitStream::read1Bit(FX_DWORD *dwResult)
     }
 }
 
-inline int32_t CJBig2_BitStream::read1Bit(FX_BOOL *bResult)
+inline int32_t CJBig2_BitStream::read1Bit(bool *bResult)
 {
     if(m_dwByteIdx < m_dwLength) {
         *bResult = (m_pBuf[m_dwByteIdx] >> (7 - m_dwBitIdx)) & 0x01;
diff --git a/core/src/fxcodec/jbig2/JBig2_Context.cpp b/core/src/fxcodec/jbig2/JBig2_Context.cpp
index 68c973547c..0b71c475c2 100644
--- a/core/src/fxcodec/jbig2/JBig2_Context.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_Context.cpp
@@ -47,7 +47,7 @@ CJBig2_Context::CJBig2_Context(uint8_t *pGlobalData, FX_DWORD dwGlobalLength,
     JBIG2_ALLOC(m_pSegmentList, CJBig2_List<CJBig2_Segment>);
     JBIG2_ALLOC(m_pPageInfoList, CJBig2_List<JBig2PageInfo>(1));
     m_pPage = NULL;
-    m_bBufSpecified = FALSE;
+    m_bBufSpecified = false;
     m_pPause = pPause;
     m_nSegmentDecoded = 0;
     m_PauseStep = 10;
@@ -231,11 +231,11 @@ int32_t CJBig2_Context::getFirstPage(uint8_t *pBuf, int32_t width, int32_t heigh
             return nRet;
         }
     }
-    m_bFirstPage = TRUE;
+    m_bFirstPage = true;
     m_PauseStep = 0;
     delete m_pPage;
     JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf));
-    m_bBufSpecified = TRUE;
+    m_bBufSpecified = true;
     if(m_pPage && pPause && pPause->NeedToPauseNow()) {
         m_PauseStep = 1;
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
@@ -298,11 +298,11 @@ int32_t CJBig2_Context::Continue(IFX_Pause* pPause)
 int32_t CJBig2_Context::getNextPage(uint8_t *pBuf, int32_t width, int32_t height, int32_t stride, IFX_Pause* pPause)
 {
     int32_t nRet = JBIG2_ERROR_STREAM_TYPE;
-    m_bFirstPage = FALSE;
+    m_bFirstPage = false;
     m_PauseStep = 0;
     delete m_pPage;
     JBIG2_ALLOC(m_pPage, CJBig2_Image(width, height, stride, pBuf));
-    m_bBufSpecified = TRUE;
+    m_bBufSpecified = true;
     if(m_pPage && pPause && pPause->NeedToPauseNow()) {
         m_PauseStep = 1;
         m_ProcessiveStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
@@ -330,7 +330,7 @@ int32_t CJBig2_Context::getNextPage(uint8_t *pBuf, int32_t width, int32_t height
 int32_t CJBig2_Context::getFirstPage(CJBig2_Image **image, IFX_Pause* pPause)
 {
     int32_t nRet;
-    m_bFirstPage = TRUE;
+    m_bFirstPage = true;
     m_PauseStep = 0;
     if(m_pGlobalContext) {
         nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
@@ -338,14 +338,14 @@ int32_t CJBig2_Context::getFirstPage(CJBig2_Image **image, IFX_Pause* pPause)
             return nRet;
         }
     }
-    m_bBufSpecified = FALSE;
+    m_bBufSpecified = false;
     return Continue(pPause);
 }
 int32_t CJBig2_Context::getNextPage(CJBig2_Image **image, IFX_Pause* pPause)
 {
     int32_t nRet;
-    m_bBufSpecified = FALSE;
-    m_bFirstPage = FALSE;
+    m_bBufSpecified = false;
+    m_bFirstPage = false;
     m_PauseStep = 0;
     switch(m_nStreamType) {
         case JBIG2_FILE_STREAM:
@@ -601,14 +601,14 @@ int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment *pSegment, IFX_Pause* pPa
     CJBig2_HuffmanTable *Table_B1 = NULL, *Table_B2 = NULL, *Table_B3 = NULL, *Table_B4 = NULL, *Table_B5 = NULL;
     int32_t i, nIndex, nRet;
     CJBig2_Segment *pSeg = NULL, *pLRSeg = NULL;
-    FX_BOOL bUsed;
+    bool bUsed;
     CJBig2_Image ** SDINSYMS = NULL;
     CJBig2_SDDProc *pSymbolDictDecoder;
     JBig2ArithCtx *gbContext = NULL, *grContext = NULL;
     CJBig2_ArithDecoder *pArithDecoder;
     JBIG2_ALLOC(pSymbolDictDecoder, CJBig2_SDDProc());
     uint8_t *key = pSegment->m_pData;
-    FX_BOOL cache_hit = false;
+    bool cache_hit = false;
     if(m_pStream->readShortInteger(&wFlags) != 0) {
         m_pModule->JBig2_Error("symbol dictionary segment : data header too short.");
         nRet = JBIG2_ERROR_TOO_SHORT;
@@ -825,16 +825,16 @@ int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment *pSegment, IFX_Pause* pPa
         }
     }
     if(wFlags & 0x0200) {
-        pSegment->m_Result.sd->m_bContextRetained = TRUE;
+        pSegment->m_Result.sd->m_bContextRetained = true;
         if(pSymbolDictDecoder->SDHUFF == 0) {
             pSegment->m_Result.sd->m_gbContext = gbContext;
         }
         if(pSymbolDictDecoder->SDREFAGG == 1) {
             pSegment->m_Result.sd->m_grContext = grContext;
         }
-        bUsed = TRUE;
+        bUsed = true;
     } else {
-        bUsed = FALSE;
+        bUsed = false;
     }
     delete pSymbolDictDecoder;
     if(SDINSYMS) {
@@ -845,7 +845,7 @@ int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment *pSegment, IFX_Pause* pPa
     delete Table_B3;
     delete Table_B4;
     delete Table_B5;
-    if(bUsed == FALSE) {
+    if(bUsed == false) {
         if(gbContext) {
             m_pModule->JBig2_Free(gbContext);
         }
diff --git a/core/src/fxcodec/jbig2/JBig2_Context.h b/core/src/fxcodec/jbig2/JBig2_Context.h
index e6a0d7b3bc..02d4192ee9 100644
--- a/core/src/fxcodec/jbig2/JBig2_Context.h
+++ b/core/src/fxcodec/jbig2/JBig2_Context.h
@@ -123,13 +123,13 @@ private:
 
     CJBig2_Image *m_pPage;
 
-    FX_BOOL m_bBufSpecified;
+    bool m_bBufSpecified;
 
     int32_t m_nSegmentDecoded;
     IFX_Pause*	m_pPause;
     int32_t	m_PauseStep;
     FXCODEC_STATUS m_ProcessiveStatus;
-    FX_BOOL	m_bFirstPage;
+    bool	m_bFirstPage;
     CJBig2_ArithDecoder *m_pArithDecoder;
     CJBig2_GRDProc *m_pGRD;
     JBig2ArithCtx *m_gbContext;
diff --git a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
index cabcd4c634..1e338a5f60 100644
--- a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.cpp
@@ -101,7 +101,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -146,7 +146,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt(CJBig2_ArithDecoder *pA
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt2(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -213,7 +213,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt2(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -305,7 +305,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -352,7 +352,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_ArithDecoder *
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -397,7 +397,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt(CJBig2_ArithDecoder *pA
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt2(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -464,7 +464,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt2(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -555,7 +555,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -600,7 +600,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_ArithDecoder *
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -643,7 +643,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt(CJBig2_ArithDecoder *pA
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt2(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -710,7 +710,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt2(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -801,7 +801,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -844,7 +844,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_ArithDecoder *
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -883,7 +883,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt(CJBig2_ArithDecoder *pA
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt2(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1;
@@ -941,7 +941,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt2(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1;
@@ -1017,7 +1017,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_ArithDecoder *p
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2;
@@ -1056,7 +1056,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_ArithDecoder *
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_V2(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG;
     FX_DWORD line1, line2, line3;
@@ -1195,7 +1195,7 @@ CJBig2_Image *CJBig2_GRDProc::decode_Arith_V2(CJBig2_ArithDecoder *pArithDecoder
 }
 CJBig2_Image *CJBig2_GRDProc::decode_Arith_V1(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT = 0;
     CJBig2_Image *GBREG;
     LTP = 0;
@@ -1340,7 +1340,7 @@ CJBig2_Image *CJBig2_GRRDProc::decode(CJBig2_ArithDecoder *pArithDecoder, JBig2A
 }
 CJBig2_Image *CJBig2_GRRDProc::decode_Template0_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GRREG;
     FX_DWORD line1, line2, line3, line4, line5;
@@ -1424,7 +1424,7 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template0_unopt(CJBig2_ArithDecoder *pArit
 }
 CJBig2_Image *CJBig2_GRRDProc::decode_Template0_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GRREG;
     FX_DWORD line1, line1_r, line2_r, line3_r;
@@ -1459,9 +1459,9 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template0_opt(CJBig2_ArithDecoder *pArithD
         }
         line1 = (h > 0) ? pLine[-nStride] << 4 : 0;
         int32_t reference_h = h - GRREFERENCEDY;
-        FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
-        FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
-        FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
+        bool line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
+        bool line2_r_ok = (reference_h > -1 && reference_h < GRHR);
+        bool line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
         line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
         line2_r = line2_r_ok ? pLineR[nOffset] : 0;
         line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
@@ -1555,7 +1555,7 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template0_opt(CJBig2_ArithDecoder *pArithD
 }
 CJBig2_Image *CJBig2_GRRDProc::decode_Template1_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GRREG;
     FX_DWORD line1, line2, line3, line4, line5;
@@ -1633,7 +1633,7 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template1_unopt(CJBig2_ArithDecoder *pArit
 }
 CJBig2_Image *CJBig2_GRRDProc::decode_Template1_opt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
+    bool LTP, SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GRREG;
     FX_DWORD line1, line1_r, line2_r, line3_r;
@@ -1668,9 +1668,9 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template1_opt(CJBig2_ArithDecoder *pArithD
         }
         line1 = (h > 0) ? pLine[-nStride] << 1 : 0;
         int32_t reference_h = h - GRREFERENCEDY;
-        FX_BOOL line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
-        FX_BOOL line2_r_ok = (reference_h > -1 && reference_h < GRHR);
-        FX_BOOL line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
+        bool line1_r_ok = (reference_h > 0 && reference_h < GRHR + 1);
+        bool line2_r_ok = (reference_h > -1 && reference_h < GRHR);
+        bool line3_r_ok = (reference_h > -2 && reference_h < GRHR - 1);
         line1_r = line1_r_ok ? pLineR[nOffset - nStrideR] : 0;
         line2_r = line2_r_ok ? pLineR[nOffset] : 0;
         line3_r = line3_r_ok ? pLineR[nOffset + nStrideR] : 0;
@@ -1758,8 +1758,8 @@ CJBig2_Image *CJBig2_GRRDProc::decode_Template1_opt(CJBig2_ArithDecoder *pArithD
 }
 CJBig2_Image *CJBig2_GRRDProc::decode_V1(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext)
 {
-    FX_BOOL LTP, SLTP, bVal;
-    FX_BOOL TPGRPIX, TPGRVAL;
+    bool LTP, SLTP, bVal;
+    bool TPGRPIX, TPGRVAL;
     FX_DWORD CONTEXT;
     CJBig2_Image *GRREG;
     LTP = 0;
@@ -1881,12 +1881,12 @@ CJBig2_Image *CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream *pStream, JBig2Ari
     CJBig2_Image *IBI;
     FX_DWORD WI, HI;
     int32_t IDS;
-    FX_BOOL RI;
+    bool RI;
     int32_t RDWI, RDHI, RDXI, RDYI;
     CJBig2_Image *IBOI;
     FX_DWORD WOI, HOI;
     CJBig2_Image *SBREG;
-    FX_BOOL bFirst;
+    bool bFirst;
     FX_DWORD nTmp;
     int32_t nVal, nBits;
     CJBig2_HuffmanDecoder *pHuffmanDecoder;
@@ -1910,7 +1910,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream *pStream, JBig2Ari
         }
         DT *= SBSTRIPS;
         STRIPT = STRIPT + DT;
-        bFirst = TRUE;
+        bFirst = true;
         for(;;) {
             if(bFirst) {
                 if(pHuffmanDecoder->decodeAValue(SBHUFFFS, &DFS) != 0) {
@@ -1919,7 +1919,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Huffman(CJBig2_BitStream *pStream, JBig2Ari
                 }
                 FIRSTS = FIRSTS + DFS;
                 CURS = FIRSTS;
-                bFirst = FALSE;
+                bFirst = false;
             } else {
                 nVal = pHuffmanDecoder->decodeAValue(SBHUFFDS, &IDS);
                 if(nVal == JBIG2_OOB) {
@@ -2106,7 +2106,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
     CJBig2_Image *IBOI;
     FX_DWORD WOI, HOI;
     CJBig2_Image *SBREG;
-    FX_BOOL bFirst;
+    bool bFirst;
     int32_t nRet, nVal;
     int32_t bRetained;
     CJBig2_ArithIntDecoder *IADT, *IAFS, *IADS, *IAIT, *IARI, *IARDW, *IARDH, *IARDX, *IARDY;
@@ -2123,7 +2123,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
         IARDX = pIDS->IARDX;
         IARDY = pIDS->IARDY;
         IAID = pIDS->IAID;
-        bRetained = TRUE;
+        bRetained = true;
     } else {
         JBIG2_ALLOC(IADT, CJBig2_ArithIntDecoder());
         JBIG2_ALLOC(IAFS, CJBig2_ArithIntDecoder());
@@ -2135,7 +2135,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
         JBIG2_ALLOC(IARDX, CJBig2_ArithIntDecoder());
         JBIG2_ALLOC(IARDY, CJBig2_ArithIntDecoder());
         JBIG2_ALLOC(IAID , CJBig2_ArithIaidDecoder(SBSYMCODELEN));
-        bRetained = FALSE;
+        bRetained = false;
     }
     JBIG2_ALLOC(SBREG, CJBig2_Image(SBW, SBH));
     SBREG->fill(SBDEFPIXEL);
@@ -2154,7 +2154,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
         }
         DT *= SBSTRIPS;
         STRIPT = STRIPT + DT;
-        bFirst = TRUE;
+        bFirst = true;
         for(;;) {
             if(bFirst) {
                 if(IAFS->decode(pArithDecoder, &DFS) == -1) {
@@ -2163,7 +2163,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
                 }
                 FIRSTS = FIRSTS + DFS;
                 CURS = FIRSTS;
-                bFirst = FALSE;
+                bFirst = false;
             } else {
                 nRet = IADS->decode(pArithDecoder, &IDS);
                 if(nRet == JBIG2_OOB) {
@@ -2299,7 +2299,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
             NINSTANCES = NINSTANCES + 1;
         }
     }
-    if(bRetained == FALSE) {
+    if(bRetained == false) {
         delete IADT;
         delete IAFS;
         delete IADS;
@@ -2313,7 +2313,7 @@ CJBig2_Image *CJBig2_TRDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecoder, J
     }
     return SBREG;
 failed:
-    if(bRetained == FALSE) {
+    if(bRetained == false) {
         delete IADT;
         delete IAFS;
         delete IADS;
@@ -2338,9 +2338,9 @@ CJBig2_SymbolDict *CJBig2_SDDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecod
     int32_t DW;
     CJBig2_Image *BS;
     FX_DWORD I, J, REFAGGNINST;
-    FX_BOOL *EXFLAGS;
+    bool *EXFLAGS;
     FX_DWORD EXINDEX;
-    FX_BOOL CUREXFLAG;
+    bool CUREXFLAG;
     FX_DWORD EXRUNLENGTH;
     int32_t nVal;
     FX_DWORD nTmp;
@@ -2585,7 +2585,7 @@ CJBig2_SymbolDict *CJBig2_SDDProc::decode_Arith(CJBig2_ArithDecoder *pArithDecod
     }
     EXINDEX = 0;
     CUREXFLAG = 0;
-    EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));
+    EXFLAGS = (bool*)m_pModule->JBig2_Malloc2(sizeof(bool), (SDNUMINSYMS + SDNUMNEWSYMS));
     while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
         if(IAEX->decode(pArithDecoder, (int*)&EXRUNLENGTH) == -1) {
             m_pModule->JBig2_Free(EXFLAGS);
@@ -2676,9 +2676,9 @@ CJBig2_SymbolDict *CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream *pStream,
     int32_t DW;
     CJBig2_Image *BS, *BHC;
     FX_DWORD I, J, REFAGGNINST;
-    FX_BOOL *EXFLAGS;
+    bool *EXFLAGS;
     FX_DWORD EXINDEX;
-    FX_BOOL CUREXFLAG;
+    bool CUREXFLAG;
     FX_DWORD EXRUNLENGTH;
     int32_t nVal, nBits;
     FX_DWORD nTmp;
@@ -2976,7 +2976,7 @@ CJBig2_SymbolDict *CJBig2_SDDProc::decode_Huffman(CJBig2_BitStream *pStream,
     CUREXFLAG = 0;
     JBIG2_ALLOC(pTable, CJBig2_HuffmanTable(HuffmanTable_B1,
                                             sizeof(HuffmanTable_B1) / sizeof(JBig2TableLine), HuffmanTable_HTOOB_B1));
-    EXFLAGS = (FX_BOOL*)m_pModule->JBig2_Malloc2(sizeof(FX_BOOL), (SDNUMINSYMS + SDNUMNEWSYMS));
+    EXFLAGS = (bool*)m_pModule->JBig2_Malloc2(sizeof(bool), (SDNUMINSYMS + SDNUMNEWSYMS));
     while(EXINDEX < SDNUMINSYMS + SDNUMNEWSYMS) {
         if(pHuffmanDecoder->decodeAValue(pTable, (int*)&EXRUNLENGTH) != 0) {
             delete pTable;
@@ -3477,7 +3477,7 @@ FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V2(CJBig2_Image** pImage, CJBi
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V2(IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     CJBig2_Image *GBREG = *m_pImage;
     FX_DWORD line1, line2, line3;
@@ -3650,7 +3650,7 @@ FXCODEC_STATUS CJBig2_GRDProc::Start_decode_Arith_V1(CJBig2_Image** pImage, CJBi
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_V1(IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT = 0;
     CJBig2_Image *GBREG = (*m_pImage);
     for(; m_loopIndex < GBH; m_loopIndex++) {
@@ -3799,7 +3799,7 @@ FXCODEC_STATUS CJBig2_GRDProc::Continue_decode(IFX_Pause* pPause)
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2;
     uint8_t *pLine1, *pLine2, cVal;
@@ -3891,7 +3891,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_opt3(CJBig2_Image *pImage,
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_Image * pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2, line3;
     for(; m_loopIndex < GBH; m_loopIndex++) {
@@ -3940,7 +3940,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template0_unopt(CJBig2_Image * pImag
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2;
     uint8_t *pLine1, *pLine2, cVal;
@@ -4031,7 +4031,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_opt3(CJBig2_Image *pImage,
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_Image * pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2, line3;
     for(FX_DWORD h = 0; h < GBH; h++) {
@@ -4078,7 +4078,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template1_unopt(CJBig2_Image * pImag
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2;
     uint8_t *pLine1, *pLine2, cVal;
@@ -4169,7 +4169,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_opt3(CJBig2_Image *pImage,
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_Image * pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2, line3;
     for(; m_loopIndex < GBH; m_loopIndex++) {
@@ -4214,7 +4214,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template2_unopt(CJBig2_Image * pImag
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_Image *pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1;
     uint8_t *pLine1, cVal;
@@ -4290,7 +4290,7 @@ FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_opt3(CJBig2_Image *pImage,
 }
 FXCODEC_STATUS CJBig2_GRDProc::decode_Arith_Template3_unopt(CJBig2_Image * pImage, CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext, IFX_Pause* pPause)
 {
-    FX_BOOL SLTP, bVal;
+    bool SLTP, bVal;
     FX_DWORD CONTEXT;
     FX_DWORD line1, line2;
     for(; m_loopIndex < GBH; m_loopIndex++) {
diff --git a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h
index 2bd2ceac95..f348e96546 100644
--- a/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h
+++ b/core/src/fxcodec/jbig2/JBig2_GeneralDecoder.h
@@ -76,7 +76,7 @@ private:
     CJBig2_ArithDecoder *m_pArithDecoder;
     JBig2ArithCtx *m_gbContext;
     FX_WORD		m_DecodeType;
-    FX_BOOL LTP;
+    bool LTP;
     FX_RECT m_ReplaceRect;
 private:
 
@@ -112,12 +112,12 @@ private:
 
     CJBig2_Image *decode_Arith_Template3_unopt(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *gbContext);
 public:
-    FX_BOOL MMR;
+    bool MMR;
     FX_DWORD GBW;
     FX_DWORD GBH;
     uint8_t GBTEMPLATE;
-    FX_BOOL TPGDON;
-    FX_BOOL USESKIP;
+    bool TPGDON;
+    bool USESKIP;
     CJBig2_Image * SKIP;
     signed char GBAT[8];
 };
@@ -139,11 +139,11 @@ public:
 public:
     FX_DWORD GRW;
     FX_DWORD GRH;
-    FX_BOOL GRTEMPLATE;
+    bool GRTEMPLATE;
     CJBig2_Image *GRREFERENCE;
     int32_t GRREFERENCEDX;
     int32_t GRREFERENCEDY;
-    FX_BOOL TPGRON;
+    bool TPGRON;
     signed char	GRAT[4];
 };
 typedef struct {
@@ -167,8 +167,8 @@ public:
     CJBig2_Image *decode_Arith(CJBig2_ArithDecoder *pArithDecoder, JBig2ArithCtx *grContext,
                                JBig2IntDecoderState *pIDS = NULL);
 public:
-    FX_BOOL SBHUFF;
-    FX_BOOL SBREFINE;
+    bool SBHUFF;
+    bool SBREFINE;
     FX_DWORD SBW;
     FX_DWORD SBH;
     FX_DWORD SBNUMINSTANCES;
@@ -179,10 +179,10 @@ public:
     uint8_t SBSYMCODELEN;
 
     CJBig2_Image **SBSYMS;
-    FX_BOOL SBDEFPIXEL;
+    bool SBDEFPIXEL;
 
     JBig2ComposeOp SBCOMBOP;
-    FX_BOOL TRANSPOSED;
+    bool TRANSPOSED;
 
     JBig2Corner REFCORNER;
     signed char SBDSOFFSET;
@@ -194,7 +194,7 @@ public:
                         *SBHUFFRDX,
                         *SBHUFFRDY,
                         *SBHUFFRSIZE;
-    FX_BOOL SBRTEMPLATE;
+    bool SBRTEMPLATE;
     signed char SBRAT[4];
 };
 class CJBig2_SDDProc : public CJBig2_Object
@@ -205,8 +205,8 @@ public:
 
     CJBig2_SymbolDict *decode_Huffman(CJBig2_BitStream *pStream, JBig2ArithCtx *gbContext, JBig2ArithCtx *grContext, IFX_Pause* pPause);
 public:
-    FX_BOOL SDHUFF;
-    FX_BOOL SDREFAGG;
+    bool SDHUFF;
+    bool SDREFAGG;
     FX_DWORD SDNUMINSYMS;
     CJBig2_Image ** SDINSYMS;
     FX_DWORD SDNUMNEWSYMS;
@@ -217,7 +217,7 @@ public:
                         *SDHUFFAGGINST;
     uint8_t SDTEMPLATE;
     signed char SDAT[8];
-    FX_BOOL SDRTEMPLATE;
+    bool SDRTEMPLATE;
     signed char SDRAT[4];
 };
 class CJBig2_HTRDProc : public CJBig2_Object
@@ -230,13 +230,13 @@ public:
 public:
     FX_DWORD HBW,
              HBH;
-    FX_BOOL HMMR;
+    bool HMMR;
     uint8_t HTEMPLATE;
     FX_DWORD HNUMPATS;
     CJBig2_Image **HPATS;
-    FX_BOOL HDEFPIXEL;
+    bool HDEFPIXEL;
     JBig2ComposeOp HCOMBOP;
-    FX_BOOL HENABLESKIP;
+    bool HENABLESKIP;
     FX_DWORD HGW,
              HGH;
     int32_t HGX,
@@ -254,7 +254,7 @@ public:
 
     CJBig2_PatternDict *decode_MMR(CJBig2_BitStream *pStream, IFX_Pause* pPause);
 public:
-    FX_BOOL HDMMR;
+    bool HDMMR;
     uint8_t HDPW,
             HDPH;
     FX_DWORD GRAYMAX;
@@ -268,8 +268,8 @@ public:
 
     FX_DWORD *decode_MMR(CJBig2_BitStream *pStream, IFX_Pause* pPause);
 public:
-    FX_BOOL GSMMR;
-    FX_BOOL GSUSESKIP;
+    bool GSMMR;
+    bool GSUSESKIP;
     uint8_t GSBPP;
     FX_DWORD GSW,
              GSH;
diff --git a/core/src/fxcodec/jbig2/JBig2_HuffmanTable.cpp b/core/src/fxcodec/jbig2/JBig2_HuffmanTable.cpp
index 0616123c1e..4932e571f2 100644
--- a/core/src/fxcodec/jbig2/JBig2_HuffmanTable.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_HuffmanTable.cpp
@@ -9,7 +9,7 @@
 #include <string.h>
 
 CJBig2_HuffmanTable::CJBig2_HuffmanTable(const JBig2TableLine *pTable, int nLines,
-        FX_BOOL bHTOOB)
+        bool bHTOOB)
 {
     init();
     m_bOK = parseFromStandardTable(pTable, nLines, bHTOOB);
@@ -38,14 +38,14 @@ CJBig2_HuffmanTable::~CJBig2_HuffmanTable()
 }
 void CJBig2_HuffmanTable::init()
 {
-    HTOOB = FALSE;
+    HTOOB = false;
     NTEMP = 0;
     CODES = NULL;
     PREFLEN = NULL;
     RANGELEN = NULL;
     RANGELOW = NULL;
 }
-int CJBig2_HuffmanTable::parseFromStandardTable(const JBig2TableLine *pTable, int nLines, FX_BOOL bHTOOB)
+int CJBig2_HuffmanTable::parseFromStandardTable(const JBig2TableLine *pTable, int nLines, bool bHTOOB)
 {
     int CURLEN, LENMAX, CURCODE, CURTEMP, i;
     int *LENCOUNT;
@@ -188,7 +188,7 @@ int CJBig2_HuffmanTable::parseFromCodedBuffer(CJBig2_BitStream *pStream)
     }
     m_pModule->JBig2_Free(LENCOUNT);
     m_pModule->JBig2_Free(FIRSTCODE);
-    return TRUE;
+    return true;
 failed:
-    return FALSE;
+    return false;
 }
diff --git a/core/src/fxcodec/jbig2/JBig2_HuffmanTable.h b/core/src/fxcodec/jbig2/JBig2_HuffmanTable.h
index d68ced2fca..d6bc3d1c4b 100644
--- a/core/src/fxcodec/jbig2/JBig2_HuffmanTable.h
+++ b/core/src/fxcodec/jbig2/JBig2_HuffmanTable.h
@@ -13,7 +13,7 @@ class CJBig2_HuffmanTable : public CJBig2_Object
 {
 public:
 
-    CJBig2_HuffmanTable(const JBig2TableLine *pTable, int nLines, FX_BOOL bHTOOB);
+    CJBig2_HuffmanTable(const JBig2TableLine *pTable, int nLines, bool bHTOOB);
 
     CJBig2_HuffmanTable(CJBig2_BitStream *pStream);
 
@@ -21,22 +21,22 @@ public:
 
     void init();
 
-    int parseFromStandardTable(const JBig2TableLine *pTable, int nLines, FX_BOOL bHTOOB);
+    int parseFromStandardTable(const JBig2TableLine *pTable, int nLines, bool bHTOOB);
 
     int parseFromCodedBuffer(CJBig2_BitStream *pStream);
 
-    FX_BOOL isOK()
+    bool isOK()
     {
         return m_bOK;
     }
 private:
-    FX_BOOL HTOOB;
+    bool HTOOB;
     int NTEMP;
     int *CODES;
     int *PREFLEN;
     int *RANGELEN;
     int *RANGELOW;
-    FX_BOOL m_bOK;
+    bool m_bOK;
     friend class CJBig2_HuffmanDecoder;
 };
 #endif
diff --git a/core/src/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h b/core/src/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h
index 428b2c3671..c08d2456d4 100644
--- a/core/src/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h
+++ b/core/src/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h
@@ -11,7 +11,7 @@ typedef struct {
     int RANDELEN;
     int RANGELOW;
 } JBig2TableLine;
-const FX_BOOL HuffmanTable_HTOOB_B1 = FALSE;
+const bool HuffmanTable_HTOOB_B1 = false;
 const JBig2TableLine HuffmanTable_B1[] = {
     { 1,	4,		0 },
     { 2,	8,	   16 },
@@ -19,7 +19,7 @@ const JBig2TableLine HuffmanTable_B1[] = {
     { 0,   32,	   -1 },
     { 3,   32,	65808 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B2 = TRUE;
+const bool HuffmanTable_HTOOB_B2 = true;
 const JBig2TableLine HuffmanTable_B2[] = {
     { 1,	0,		0 },
     { 2,	0,		1 },
@@ -30,7 +30,7 @@ const JBig2TableLine HuffmanTable_B2[] = {
     { 6,   32,     75 },
     { 6,	0,      0 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B3 = TRUE;
+const bool HuffmanTable_HTOOB_B3 = true;
 const JBig2TableLine HuffmanTable_B3[] = {
     { 8,	8,   -256 },
     { 1,	0,		0 },
@@ -42,7 +42,7 @@ const JBig2TableLine HuffmanTable_B3[] = {
     { 7,   32,     75 },
     { 6,	0,		0 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B4 = FALSE;
+const bool HuffmanTable_HTOOB_B4 = false;
 const JBig2TableLine HuffmanTable_B4[] = {
     { 1,	0,		1 },
     { 2,	0,		2 },
@@ -52,7 +52,7 @@ const JBig2TableLine HuffmanTable_B4[] = {
     { 0,   32,     -1 },
     { 5,   32,	   76 },
 };
-const FX_BOOL HuffmanTable_HTOOB_B5 = FALSE;
+const bool HuffmanTable_HTOOB_B5 = false;
 const JBig2TableLine HuffmanTable_B5[] = {
     { 7,	8,	 -255 },
     { 1,	0,	    1 },
@@ -63,7 +63,7 @@ const JBig2TableLine HuffmanTable_B5[] = {
     { 7,   32,   -256 },
     { 6,   32,     76 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B6 = FALSE;
+const bool HuffmanTable_HTOOB_B6 = false;
 const JBig2TableLine HuffmanTable_B6[] = {
     { 5,   10,	-2048 },
     { 4,    9,	-1024 },
@@ -80,7 +80,7 @@ const JBig2TableLine HuffmanTable_B6[] = {
     { 6,   32,	-2049 },
     { 6,   32,	 2048 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B7 = FALSE;
+const bool HuffmanTable_HTOOB_B7 = false;
 const JBig2TableLine HuffmanTable_B7[] = {
     { 4,	9,	-1024 },
     { 3,	8,	 -512 },
@@ -98,7 +98,7 @@ const JBig2TableLine HuffmanTable_B7[] = {
     { 5,   32,	-1025 },
     { 5,   32,	 2048 },
 };
-const FX_BOOL HuffmanTable_HTOOB_B8 = TRUE;
+const bool HuffmanTable_HTOOB_B8 = true;
 const JBig2TableLine HuffmanTable_B8[] = {
     { 8,	3,	  -15 },
     { 9,	1,	   -7 },
@@ -122,7 +122,7 @@ const JBig2TableLine HuffmanTable_B8[] = {
     { 9,   32,	 1670 },
     { 2,	0,		0 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B9 = TRUE;
+const bool HuffmanTable_HTOOB_B9 = true;
 const JBig2TableLine HuffmanTable_B9[] = {
     { 8,	4,	  -31 },
     { 9,	2,	  -15 },
@@ -147,7 +147,7 @@ const JBig2TableLine HuffmanTable_B9[] = {
     { 9,   32,	 3339 },
     { 2,	0,		0 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B10 = TRUE;
+const bool HuffmanTable_HTOOB_B10 = true;
 const JBig2TableLine HuffmanTable_B10[] = {
     { 7,	4,	  -21 },
     { 8,	0,	   -5 },
@@ -171,7 +171,7 @@ const JBig2TableLine HuffmanTable_B10[] = {
     { 8,   32,	 4166 },
     { 2,	0,		0 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B11 = FALSE;
+const bool HuffmanTable_HTOOB_B11 = false;
 const JBig2TableLine HuffmanTable_B11[] = {
     { 1,	0,		1 },
     { 2,	1,		2 },
@@ -188,7 +188,7 @@ const JBig2TableLine HuffmanTable_B11[] = {
     { 0,   32,		0 },
     { 7,   32,	  141 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B12 = FALSE;
+const bool HuffmanTable_HTOOB_B12 = false;
 const JBig2TableLine HuffmanTable_B12[] = {
     { 1,	0,		1 },
     { 2,	0,		2 },
@@ -205,7 +205,7 @@ const JBig2TableLine HuffmanTable_B12[] = {
     { 0,   32,		0 },
     { 8,   32,	   73 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B13 = FALSE;
+const bool HuffmanTable_HTOOB_B13 = false;
 const JBig2TableLine HuffmanTable_B13[] = {
     { 1,	0,		1 },
     { 3,	0,		2 },
@@ -222,7 +222,7 @@ const JBig2TableLine HuffmanTable_B13[] = {
     { 0,   32,		0 },
     { 7,   32,	  141 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B14 = FALSE;
+const bool HuffmanTable_HTOOB_B14 = false;
 const JBig2TableLine HuffmanTable_B14[] = {
     { 3,	0,	   -2 },
     { 3,	0,	   -1 },
@@ -232,7 +232,7 @@ const JBig2TableLine HuffmanTable_B14[] = {
     { 0,   32,	   -3 },
     { 0,   32,		3 }
 };
-const FX_BOOL HuffmanTable_HTOOB_B15 = FALSE;
+const bool HuffmanTable_HTOOB_B15 = false;
 const JBig2TableLine HuffmanTable_B15[] = {
     { 7,	4,	  -24 },
     { 6,	2,	   -8 },
diff --git a/core/src/fxcodec/jbig2/JBig2_Image.cpp b/core/src/fxcodec/jbig2/JBig2_Image.cpp
index 9ef4464ef0..030b0c2493 100644
--- a/core/src/fxcodec/jbig2/JBig2_Image.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_Image.cpp
@@ -16,7 +16,7 @@ CJBig2_Image::CJBig2_Image(int32_t w, int32_t h)
     m_nHeight	= h;
     if (m_nWidth <= 0 || m_nHeight <= 0 || m_nWidth > INT_MAX - 31) {
         m_pData = NULL;
-        m_bNeedFree = FALSE;
+        m_bNeedFree = false;
         return;
     }
     m_nStride  = ((w + 31) >> 5) << 2;
@@ -25,7 +25,7 @@ CJBig2_Image::CJBig2_Image(int32_t w, int32_t h)
     } else {
         m_pData = NULL;
     }
-    m_bNeedFree = TRUE;
+    m_bNeedFree = true;
 }
 CJBig2_Image::CJBig2_Image(int32_t w, int32_t h, int32_t stride, uint8_t*pBuf)
 {
@@ -33,7 +33,7 @@ CJBig2_Image::CJBig2_Image(int32_t w, int32_t h, int32_t stride, uint8_t*pBuf)
     m_nHeight = h;
     m_nStride = stride;
     m_pData = pBuf;
-    m_bNeedFree = FALSE;
+    m_bNeedFree = false;
 }
 CJBig2_Image::CJBig2_Image(CJBig2_Image &im)
 {
@@ -47,7 +47,7 @@ CJBig2_Image::CJBig2_Image(CJBig2_Image &im)
     } else {
         m_pData = NULL;
     }
-    m_bNeedFree = TRUE;
+    m_bNeedFree = true;
 }
 CJBig2_Image::~CJBig2_Image()
 {
@@ -55,7 +55,7 @@ CJBig2_Image::~CJBig2_Image()
         m_pModule->JBig2_Free(m_pData);
     }
 }
-FX_BOOL CJBig2_Image::getPixel(int32_t x, int32_t y)
+bool CJBig2_Image::getPixel(int32_t x, int32_t y)
 {
     if (!m_pData) {
         return 0;
@@ -72,7 +72,7 @@ FX_BOOL CJBig2_Image::getPixel(int32_t x, int32_t y)
     return ((m_pData[m] >> (7 - n)) & 1);
 }
 
-int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, FX_BOOL v)
+int32_t CJBig2_Image::setPixel(int32_t x, int32_t y, bool v)
 {
     if (!m_pData) {
         return 0;
@@ -104,31 +104,31 @@ void CJBig2_Image::copyLine(int32_t hTo, int32_t hFrom)
         JBIG2_memcpy(m_pData + hTo * m_nStride, m_pData + hFrom * m_nStride, m_nStride);
     }
 }
-void CJBig2_Image::fill(FX_BOOL v)
+void CJBig2_Image::fill(bool v)
 {
     if (!m_pData) {
         return;
     }
     JBIG2_memset(m_pData, v ? 0xff : 0, m_nStride * m_nHeight);
 }
-FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return composeTo_opt2(pDst, x, y, op);
 }
-FX_BOOL CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (NULL == pSrcRect || *pSrcRect == FX_RECT(0, 0, m_nWidth, m_nHeight)) {
         return composeTo_opt2(pDst, x, y, op);
     }
     return composeTo_opt2(pDst, x, y, op, pSrcRect);
 }
-FX_BOOL CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t w, h, dx, dy;
     int32_t i, j;
@@ -192,17 +192,17 @@ FX_BOOL CJBig2_Image::composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y,
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 
-FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t x0, x1, y0, y1, xx, yy;
     uint8_t *pLineSrc, *pLineDst, *srcPtr, *destPtr;
     FX_DWORD src0, src1, src, dest, s1, s2, m1, m2, m3;
-    FX_BOOL oneByte;
+    bool oneByte;
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (y < 0) {
         y0 = -y;
@@ -215,7 +215,7 @@ FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JB
         y1 = m_nHeight;
     }
     if (y0 >= y1) {
-        return FALSE;
+        return false;
     }
     if (x >= 0) {
         x0 = x & ~7;
@@ -227,7 +227,7 @@ FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JB
         x1 = pDst->m_nWidth;
     }
     if (x0 >= x1) {
-        return FALSE;
+        return false;
     }
     s1 = x & 7;
     s2 = 8 - s1;
@@ -679,19 +679,19 @@ FX_BOOL CJBig2_Image::composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JB
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op)
+bool CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return pSrc->composeTo(this, x, y, op);
 }
-FX_BOOL CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     return pSrc->composeTo(this, x, y, op, pSrcRect);
 }
@@ -765,7 +765,7 @@ CJBig2_Image *CJBig2_Image::subImage(int32_t x, int32_t y, int32_t w, int32_t h)
     }
     return pImage;
 }
-void CJBig2_Image::expand(int32_t h, FX_BOOL v)
+void CJBig2_Image::expand(int32_t h, bool v)
 {
     if (!m_pData || h <= m_nHeight) {
         return;
@@ -788,7 +788,7 @@ void CJBig2_Image::expand(int32_t h, FX_BOOL v)
     JBIG2_memset(m_pData + dwHeight * dwStride, v ? 0xff : 0, (dwH - dwHeight) * dwStride);
     m_nHeight = h;
 }
-FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
+bool CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op)
 {
     int32_t xs0 = 0, ys0  = 0, xs1  = 0, ys1   = 0, xd0    = 0, yd0          = 0, xd1      = 0, 
              yd1 = 0, xx   = 0, yy   = 0, w     = 0, h      = 0, middleDwords = 0, lineLeft = 0;
@@ -799,10 +799,10 @@ FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, J
     uint8_t *lineSrc = NULL, *lineDst = NULL, *sp = NULL, *dp = NULL;
 
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
-        return FALSE;
+        return false;
     }
     if(y < 0) {
         ys0 = -y;
@@ -1205,17 +1205,17 @@ FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, J
     }
     return 1;
 }
-FX_BOOL CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
+bool CJBig2_Image::composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect)
 {
     int32_t xs0, ys0, xs1, ys1, xd0, yd0, xd1, yd1, xx, yy, w, h, middleDwords, lineLeft;
     FX_DWORD s1, d1, d2, shift, shift1, shift2, tmp, tmp1, tmp2, maskL, maskR, maskM;
     uint8_t *lineSrc, *lineDst, *sp, *dp;
     int32_t sw, sh;
     if (!m_pData) {
-        return FALSE;
+        return false;
     }
     if (x < -1048576 || x > 1048576 || y < -1048576 || y > 1048576) {
-        return FALSE;
+        return false;
     }
     sw = pSrcRect->Width();
     sh = pSrcRect->Height();
diff --git a/core/src/fxcodec/jbig2/JBig2_Image.h b/core/src/fxcodec/jbig2/JBig2_Image.h
index 423bebcede..d51d99907d 100644
--- a/core/src/fxcodec/jbig2/JBig2_Image.h
+++ b/core/src/fxcodec/jbig2/JBig2_Image.h
@@ -28,31 +28,31 @@ public:
 
     ~CJBig2_Image();
 
-    FX_BOOL getPixel(int32_t x, int32_t y);
+    bool getPixel(int32_t x, int32_t y);
 
-    int32_t setPixel(int32_t x, int32_t y, FX_BOOL v);
+    int32_t setPixel(int32_t x, int32_t y, bool v);
 
     void copyLine(int32_t hTo, int32_t hFrom);
 
-    void fill(FX_BOOL v);
+    void fill(bool v);
 
-    FX_BOOL composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
-    FX_BOOL composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect);
+    bool composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
+    bool composeTo(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect);
 
-    FX_BOOL composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
+    bool composeTo_unopt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
 
-    FX_BOOL composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
+    bool composeTo_opt(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
 
-    FX_BOOL composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
-    FX_BOOL composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect);
+    bool composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op);
+    bool composeTo_opt2(CJBig2_Image *pDst, int32_t x, int32_t y, JBig2ComposeOp op, const FX_RECT* pSrcRect);
 
-    FX_BOOL composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op);
-    FX_BOOL composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect);
+    bool composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op);
+    bool composeFrom(int32_t x, int32_t y, CJBig2_Image *pSrc, JBig2ComposeOp op, const FX_RECT* pSrcRect);
     CJBig2_Image *subImage_unopt(int32_t x, int32_t y, int32_t w, int32_t h);
 
     CJBig2_Image *subImage(int32_t x, int32_t y, int32_t w, int32_t h);
 
-    void expand(int32_t h, FX_BOOL v);
+    void expand(int32_t h, bool v);
 public:
 
     int32_t m_nWidth;
@@ -63,6 +63,6 @@ public:
 
     uint8_t *m_pData;
 
-    FX_BOOL m_bNeedFree;
+    bool m_bNeedFree;
 };
 #endif
diff --git a/core/src/fxcodec/jbig2/JBig2_Page.h b/core/src/fxcodec/jbig2/JBig2_Page.h
index b07eba8a3a..b4e159f2a2 100644
--- a/core/src/fxcodec/jbig2/JBig2_Page.h
+++ b/core/src/fxcodec/jbig2/JBig2_Page.h
@@ -13,7 +13,7 @@ struct JBig2PageInfo : public CJBig2_Object {
     FX_DWORD m_dwResolutionX,
              m_dwResolutionY;
     uint8_t m_cFlags;
-    FX_BOOL m_bIsStriped;
+    bool m_bIsStriped;
     FX_WORD m_wMaxStripeSize;
 };
 #endif
diff --git a/core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp b/core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp
index 0e5b92ff5a..c10d461623 100644
--- a/core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp
+++ b/core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp
@@ -9,7 +9,7 @@ CJBig2_SymbolDict::CJBig2_SymbolDict()
 {
     SDNUMEXSYMS = 0;
     SDEXSYMS = NULL;
-    m_bContextRetained = FALSE;
+    m_bContextRetained = false;
     m_gbContext = m_grContext = NULL;
 }
 
diff --git a/core/src/fxcodec/jbig2/JBig2_SymbolDict.h b/core/src/fxcodec/jbig2/JBig2_SymbolDict.h
index 9156e30ea8..5f94dc7be8 100644
--- a/core/src/fxcodec/jbig2/JBig2_SymbolDict.h
+++ b/core/src/fxcodec/jbig2/JBig2_SymbolDict.h
@@ -19,7 +19,7 @@ public:
 public:
     FX_DWORD SDNUMEXSYMS;
     CJBig2_Image **SDEXSYMS;
-    FX_BOOL m_bContextRetained;
+    bool m_bContextRetained;
     JBig2ArithCtx *m_gbContext,
                   *m_grContext;
 };
diff --git a/core/src/fxcrt/extension.h b/core/src/fxcrt/extension.h
index ba42916599..2d7f3ae220 100644
--- a/core/src/fxcrt/extension.h
+++ b/core/src/fxcrt/extension.h
@@ -14,8 +14,8 @@ class IFXCRT_FileAccess
 {
 public:
     virtual ~IFXCRT_FileAccess() {}
-    virtual FX_BOOL		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode) = 0;
-    virtual FX_BOOL		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode) = 0;
+    virtual bool		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode) = 0;
+    virtual bool		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode) = 0;
     virtual void		Close() = 0;
     virtual void		Release() = 0;
     virtual FX_FILESIZE	GetSize() const = 0;
@@ -25,14 +25,14 @@ public:
     virtual size_t		Write(const void* pBuffer, size_t szBuffer) = 0;
     virtual size_t		ReadPos(void* pBuffer, size_t szBuffer, FX_FILESIZE pos) = 0;
     virtual size_t		WritePos(const void* pBuffer, size_t szBuffer, FX_FILESIZE pos) = 0;
-    virtual FX_BOOL		Flush() = 0;
-    virtual FX_BOOL		Truncate(FX_FILESIZE szFile) = 0;
+    virtual bool		Flush() = 0;
+    virtual bool		Truncate(FX_FILESIZE szFile) = 0;
 };
 IFXCRT_FileAccess*	FXCRT_FileAccess_Create();
 class CFX_CRTFileStream final : public IFX_FileStream
 {
 public:
-    CFX_CRTFileStream(IFXCRT_FileAccess* pFA) : m_pFile(pFA), m_dwCount(1), m_bUseRange(FALSE), m_nOffset(0), m_nSize(0) {}
+    CFX_CRTFileStream(IFXCRT_FileAccess* pFA) : m_pFile(pFA), m_dwCount(1), m_bUseRange(false), m_nOffset(0), m_nSize(0) {}
     ~CFX_CRTFileStream()
     {
         if (m_pFile) {
@@ -55,7 +55,7 @@ public:
     {
         return m_bUseRange ? m_nSize : m_pFile->GetSize();
     }
-    virtual FX_BOOL				IsEOF() override
+    virtual bool				IsEOF() override
     {
         return GetPosition() >= GetSize();
     }
@@ -67,42 +67,42 @@ public:
         }
         return pos;
     }
-    virtual FX_BOOL				SetRange(FX_FILESIZE offset, FX_FILESIZE size) override
+    virtual bool				SetRange(FX_FILESIZE offset, FX_FILESIZE size) override
     {
         if (offset < 0 || size < 0) {
-            return FALSE;
+            return false;
         }
 
         FX_SAFE_FILESIZE pos = size;
         pos += offset;
 
         if (!pos.IsValid() || pos.ValueOrDie() > m_pFile->GetSize()) {
-            return FALSE;
+            return false;
         }
 
         m_nOffset = offset, m_nSize = size;
-        m_bUseRange = TRUE;
+        m_bUseRange = true;
         m_pFile->SetPosition(m_nOffset);
-        return TRUE;
+        return true;
     }
     virtual void				ClearRange() override
     {
-        m_bUseRange = FALSE;
+        m_bUseRange = false;
     }
-    virtual FX_BOOL				ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override
+    virtual bool				ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override
     {
         if (m_bUseRange && offset < 0) {
-            return FALSE;
+            return false;
         }
         FX_SAFE_FILESIZE pos = offset;
 
         if (m_bUseRange) {
             pos += m_nOffset;
             if (!pos.IsValid() || pos.ValueOrDie() > (size_t)GetSize()) {
-                return FALSE;
+                return false;
             }
         }
-        return (FX_BOOL)m_pFile->ReadPos(buffer, size, pos.ValueOrDie());
+        return (bool)m_pFile->ReadPos(buffer, size, pos.ValueOrDie());
     }
     virtual size_t				ReadBlock(void* buffer, size_t size) override
     {
@@ -114,20 +114,20 @@ public:
         }
         return m_pFile->Read(buffer, size);
     }
-    virtual	FX_BOOL				WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) override
+    virtual	bool				WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) override
     {
         if (m_bUseRange) {
             offset += m_nOffset;
         }
-        return (FX_BOOL)m_pFile->WritePos(buffer, size, offset);
+        return (bool)m_pFile->WritePos(buffer, size, offset);
     }
-    virtual FX_BOOL				Flush()  override
+    virtual bool				Flush()  override
     {
         return m_pFile->Flush();
     }
     IFXCRT_FileAccess*	m_pFile;
     FX_DWORD			m_dwCount;
-    FX_BOOL				m_bUseRange;
+    bool				m_bUseRange;
     FX_FILESIZE			m_nOffset;
     FX_FILESIZE			m_nSize;
 };
@@ -137,23 +137,23 @@ public:
 class CFX_MemoryStream final : public IFX_MemoryStream
 {
 public:
-    CFX_MemoryStream(FX_BOOL bConsecutive)
+    CFX_MemoryStream(bool bConsecutive)
         : m_dwCount(1)
         , m_nTotalSize(0)
         , m_nCurSize(0)
         , m_nCurPos(0)
         , m_nGrowSize(FX_MEMSTREAM_BlockSize)
-        , m_bUseRange(FALSE)
+        , m_bUseRange(false)
     {
         m_dwFlags = FX_MEMSTREAM_TakeOver | (bConsecutive ? FX_MEMSTREAM_Consecutive : 0);
     }
-    CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, FX_BOOL bTakeOver)
+    CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, bool bTakeOver)
         : m_dwCount(1)
         , m_nTotalSize(nSize)
         , m_nCurSize(nSize)
         , m_nCurPos(0)
         , m_nGrowSize(FX_MEMSTREAM_BlockSize)
-        , m_bUseRange(FALSE)
+        , m_bUseRange(false)
     {
         m_Blocks.Add(pBuffer);
         m_dwFlags = FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
@@ -184,7 +184,7 @@ public:
     {
         return m_bUseRange ? (FX_FILESIZE) m_nSize : (FX_FILESIZE)m_nCurSize;
     }
-    virtual FX_BOOL				IsEOF()  override
+    virtual bool				IsEOF()  override
     {
         return m_nCurPos >= (size_t)GetSize();
     }
@@ -196,30 +196,30 @@ public:
         }
         return pos;
     }
-    virtual FX_BOOL				SetRange(FX_FILESIZE offset, FX_FILESIZE size)  override
+    virtual bool				SetRange(FX_FILESIZE offset, FX_FILESIZE size)  override
     {
         if (offset < 0 || size < 0) {
-            return FALSE;
+            return false;
         }
         FX_SAFE_FILESIZE range = size;
         range += offset;
         if (!range.IsValid() || range.ValueOrDie() > m_nCurSize) {
-            return FALSE;
+            return false;
         }
 
         m_nOffset = (size_t)offset, m_nSize = (size_t)size;
-        m_bUseRange = TRUE;
+        m_bUseRange = true;
         m_nCurPos = m_nOffset;
-        return TRUE;
+        return true;
     }
     virtual void				ClearRange()  override
     {
-        m_bUseRange = FALSE;
+        m_bUseRange = false;
     }
-    virtual FX_BOOL				ReadBlock(void* buffer, FX_FILESIZE offset, size_t size)  override
+    virtual bool				ReadBlock(void* buffer, FX_FILESIZE offset, size_t size)  override
     {
         if (!buffer || !size) {
-            return FALSE;
+            return false;
         }
 
         FX_SAFE_FILESIZE safeOffset = offset;
@@ -228,7 +228,7 @@ public:
         }
 
         if (!safeOffset.IsValid()) {
-            return FALSE;
+            return false;
         }
 
         offset = safeOffset.ValueOrDie();
@@ -236,13 +236,13 @@ public:
         FX_SAFE_SIZE_T newPos = size;
         newPos += offset;
         if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 || newPos.ValueOrDie() > m_nCurSize) {
-            return FALSE;
+            return false;
         }
 
         m_nCurPos = newPos.ValueOrDie();
         if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
             FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
-            return TRUE;
+            return true;
         }
         size_t nStartBlock = (size_t)offset / m_nGrowSize;
         offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
@@ -257,7 +257,7 @@ public:
             nStartBlock ++;
             offset = 0;
         }
-        return TRUE;
+        return true;
     }
     virtual size_t				ReadBlock(void* buffer, size_t size)  override
     {
@@ -276,10 +276,10 @@ public:
         }
         return nRead;
     }
-    virtual	FX_BOOL				WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)  override
+    virtual	bool				WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)  override
     {
         if (!buffer || !size) {
-            return FALSE;
+            return false;
         }
         if (m_bUseRange) {
             offset += (FX_FILESIZE)m_nOffset;
@@ -288,7 +288,7 @@ public:
             FX_SAFE_SIZE_T newPos = size;
             newPos += offset;
             if (!newPos.IsValid())
-                return FALSE;
+                return false;
 
             m_nCurPos = newPos.ValueOrDie();
             if (m_nCurPos > m_nTotalSize) {
@@ -301,24 +301,24 @@ public:
                 }
                 if (!m_Blocks[0]) {
                     m_Blocks.RemoveAll();
-                    return FALSE;
+                    return false;
                 }
             }
             FXSYS_memcpy((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
             if (m_nCurSize < m_nCurPos) {
                 m_nCurSize = m_nCurPos;
             }
-            return TRUE;
+            return true;
         }
 
         FX_SAFE_SIZE_T newPos = size;
         newPos += offset;
         if (!newPos.IsValid()) {
-            return FALSE;
+            return false;
         }
 
         if (!ExpandBlocks(newPos.ValueOrDie())) {
-            return FALSE;
+            return false;
         }
         m_nCurPos = newPos.ValueOrDie();
         size_t nStartBlock = (size_t)offset / m_nGrowSize;
@@ -334,13 +334,13 @@ public:
             nStartBlock ++;
             offset = 0;
         }
-        return TRUE;
+        return true;
     }
-    virtual FX_BOOL				Flush()  override
+    virtual bool				Flush()  override
     {
-        return TRUE;
+        return true;
     }
-    virtual FX_BOOL				IsConsecutive() const  override
+    virtual bool				IsConsecutive() const  override
     {
         return m_dwFlags & FX_MEMSTREAM_Consecutive;
     }
@@ -360,7 +360,7 @@ public:
     {
         return m_Blocks.GetSize() ? (uint8_t*)m_Blocks[0] : NULL;
     }
-    virtual void				AttachBuffer(uint8_t* pBuffer, size_t nSize, FX_BOOL bTakeOver = FALSE)  override
+    virtual void				AttachBuffer(uint8_t* pBuffer, size_t nSize, bool bTakeOver = false)  override
     {
         if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
             return;
@@ -390,16 +390,16 @@ protected:
     size_t			m_nCurPos;
     size_t			m_nGrowSize;
     FX_DWORD		m_dwFlags;
-    FX_BOOL			m_bUseRange;
+    bool			m_bUseRange;
     size_t			m_nOffset;
     size_t			m_nSize;
-    FX_BOOL	ExpandBlocks(size_t size)
+    bool	ExpandBlocks(size_t size)
     {
         if (m_nCurSize < size) {
             m_nCurSize = size;
         }
         if (size <= m_nTotalSize) {
-            return TRUE;
+            return true;
         }
         int32_t iCount = m_Blocks.GetSize();
         size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
@@ -409,7 +409,7 @@ protected:
             m_Blocks.SetAt(iCount ++, pBlock);
             m_nTotalSize += m_nGrowSize;
         }
-        return TRUE;
+        return true;
     }
 };
 #ifdef __cplusplus
@@ -424,15 +424,15 @@ typedef struct _FX_MTRANDOMCONTEXT {
     _FX_MTRANDOMCONTEXT()
     {
         mti = MT_N + 1;
-        bHaveSeed = FALSE;
+        bHaveSeed = false;
     }
     FX_DWORD mti;
-    FX_BOOL	 bHaveSeed;
+    bool	 bHaveSeed;
     FX_DWORD mt[MT_N];
 } FX_MTRANDOMCONTEXT, * FX_LPMTRANDOMCONTEXT;
 typedef FX_MTRANDOMCONTEXT const * FX_LPCMTRANDOMCONTEXT;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-FX_BOOL FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount);
+bool FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount);
 #endif
 #ifdef __cplusplus
 }
diff --git a/core/src/fxcrt/fx_arabic.cpp b/core/src/fxcrt/fx_arabic.cpp
index 3cb2fd067a..497c1bab4f 100644
--- a/core/src/fxcrt/fx_arabic.cpp
+++ b/core/src/fxcrt/fx_arabic.cpp
@@ -13,7 +13,7 @@ IFX_BidiChar* IFX_BidiChar::Create()
     return new CFX_BidiChar;
 }
 CFX_BidiChar::CFX_BidiChar()
-    : m_bSeparateNeutral(TRUE)
+    : m_bSeparateNeutral(true)
     , m_iCurStart(0)
     , m_iCurCount(0)
     , m_iCurBidi(0)
@@ -22,12 +22,12 @@ CFX_BidiChar::CFX_BidiChar()
     , m_iLastCount(0)
 {
 }
-void CFX_BidiChar::SetPolicy(FX_BOOL bSeparateNeutral)
+void CFX_BidiChar::SetPolicy(bool bSeparateNeutral)
 {
     m_bSeparateNeutral = bSeparateNeutral;
 }
 
-FX_BOOL CFX_BidiChar::AppendChar(FX_WCHAR wch)
+bool CFX_BidiChar::AppendChar(FX_WCHAR wch)
 {
     FX_DWORD dwProps = gs_FX_TextLayout_CodeProperties[(FX_WORD)wch];
     int32_t iBidiCls = (dwProps & FX_BIDICLASSBITSMASK) >> FX_BIDICLASSBITS;
@@ -43,10 +43,10 @@ FX_BOOL CFX_BidiChar::AppendChar(FX_WCHAR wch)
             iContext = 2;
             break;
     }
-    FX_BOOL bRet = FALSE;
+    bool bRet = false;
     if (iContext != m_iCurBidi) {
         if (m_bSeparateNeutral) {
-            bRet = TRUE;
+            bRet = true;
         } else {
             if (m_iCurBidi == 0) {
                 bRet = (m_iCurCount > 0);
@@ -67,7 +67,7 @@ FX_BOOL CFX_BidiChar::AppendChar(FX_WCHAR wch)
     m_iCurCount ++;
     return bRet;
 }
-FX_BOOL CFX_BidiChar::EndChar()
+bool CFX_BidiChar::EndChar()
 {
     m_iLastBidi = m_iCurBidi;
     m_iLastStart = m_iCurStart;
diff --git a/core/src/fxcrt/fx_arabic.h b/core/src/fxcrt/fx_arabic.h
index e4c1ddacf2..10a16afa63 100644
--- a/core/src/fxcrt/fx_arabic.h
+++ b/core/src/fxcrt/fx_arabic.h
@@ -15,14 +15,14 @@ public:
     CFX_BidiChar();
     ~CFX_BidiChar() override {}
 
-    void SetPolicy(FX_BOOL bSeparateNeutral = TRUE) override;
-    FX_BOOL AppendChar(FX_WCHAR wch) override;
-    FX_BOOL EndChar() override;
+    void SetPolicy(bool bSeparateNeutral = true) override;
+    bool AppendChar(FX_WCHAR wch) override;
+    bool EndChar() override;
     int32_t GetBidiInfo(int32_t &iStart, int32_t &iCount) override;
     void Reset() override;
 
 private:
-    FX_BOOL	m_bSeparateNeutral;
+    bool	m_bSeparateNeutral;
     int32_t	m_iCurStart;
     int32_t	m_iCurCount;
     int32_t	m_iCurBidi;
diff --git a/core/src/fxcrt/fx_basic_array.cpp b/core/src/fxcrt/fx_basic_array.cpp
index 4ab34bb022..f139365740 100644
--- a/core/src/fxcrt/fx_basic_array.cpp
+++ b/core/src/fxcrt/fx_basic_array.cpp
@@ -22,7 +22,7 @@ CFX_BasicArray::~CFX_BasicArray()
 {
     FX_Free(m_pData);
 }
-FX_BOOL CFX_BasicArray::SetSize(int nNewSize)
+bool CFX_BasicArray::SetSize(int nNewSize)
 {
     if (nNewSize <= 0) {
         FX_Free(m_pData);
@@ -36,7 +36,7 @@ FX_BOOL CFX_BasicArray::SetSize(int nNewSize)
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid()) {
             m_nSize = m_nMaxSize = 0;
-            return FALSE;
+            return false;
         }
         m_pData = FX_Alloc(uint8_t, totalSize.ValueOrDie());
         m_nSize = m_nMaxSize = nNewSize;
@@ -50,38 +50,38 @@ FX_BOOL CFX_BasicArray::SetSize(int nNewSize)
         pdfium::base::CheckedNumeric<int> totalSize = nNewMax;
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid() || nNewMax < m_nSize) {
-            return FALSE;
+            return false;
         }
         uint8_t* pNewData = FX_Realloc(uint8_t, m_pData, totalSize.ValueOrDie());
         if (pNewData == NULL) {
-            return FALSE;
+            return false;
         }
         FXSYS_memset(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
         m_pData = pNewData;
         m_nSize = nNewSize;
         m_nMaxSize = nNewMax;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::Append(const CFX_BasicArray& src)
+bool CFX_BasicArray::Append(const CFX_BasicArray& src)
 {
     int nOldSize = m_nSize;
     pdfium::base::CheckedNumeric<int> newSize = m_nSize;
     newSize += src.m_nSize;
     if (m_nUnitSize != src.m_nUnitSize || !newSize.IsValid() || !SetSize(newSize.ValueOrDie())) {
-        return FALSE;
+        return false;
     }
 
     FXSYS_memcpy(m_pData + nOldSize * m_nUnitSize, src.m_pData, src.m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::Copy(const CFX_BasicArray& src)
+bool CFX_BasicArray::Copy(const CFX_BasicArray& src)
 {
     if (!SetSize(src.m_nSize)) {
-        return FALSE;
+        return false;
     }
     FXSYS_memcpy(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
 uint8_t* CFX_BasicArray::InsertSpaceAt(int nIndex, int nCount)
 {
@@ -103,31 +103,31 @@ uint8_t* CFX_BasicArray::InsertSpaceAt(int nIndex, int nCount)
     }
     return m_pData + nIndex * m_nUnitSize;
 }
-FX_BOOL CFX_BasicArray::RemoveAt(int nIndex, int nCount)
+bool CFX_BasicArray::RemoveAt(int nIndex, int nCount)
 {
     if (nIndex < 0 || nCount <= 0 || m_nSize < nIndex + nCount) {
-        return FALSE;
+        return false;
     }
     int nMoveCount = m_nSize - (nIndex + nCount);
     if (nMoveCount) {
         FXSYS_memmove(m_pData + nIndex * m_nUnitSize, m_pData + (nIndex + nCount) * m_nUnitSize, nMoveCount * m_nUnitSize);
     }
     m_nSize -= nCount;
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
+bool CFX_BasicArray::InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
 {
     if (pNewArray == NULL) {
-        return FALSE;
+        return false;
     }
     if (pNewArray->m_nSize == 0) {
-        return TRUE;
+        return true;
     }
     if (!InsertSpaceAt(nStartIndex, pNewArray->m_nSize)) {
-        return FALSE;
+        return false;
     }
     FXSYS_memcpy(m_pData + nStartIndex * m_nUnitSize, pNewArray->m_pData, pNewArray->m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
 const void* CFX_BasicArray::GetDataPtr(int index) const
 {
@@ -260,7 +260,7 @@ void** CFX_BaseSegmentedArray::GetIndex(int seg_index) const
     }
     return pSpot;
 }
-void* CFX_BaseSegmentedArray::IterateSegment(const uint8_t* pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::IterateSegment(const uint8_t* pSegment, int count, bool (*callback)(void* param, void* pData), void* param) const
 {
     for (int i = 0; i < count; i ++) {
         if (!callback(param, (void*)(pSegment + i * m_UnitSize))) {
@@ -269,7 +269,7 @@ void* CFX_BaseSegmentedArray::IterateSegment(const uint8_t* pSegment, int count,
     }
     return NULL;
 }
-void* CFX_BaseSegmentedArray::IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::IterateIndex(int level, int& start, void** pIndex, bool (*callback)(void* param, void* pData), void* param) const
 {
     if (level == 0) {
         int count = m_DataSize - start;
@@ -290,7 +290,7 @@ void* CFX_BaseSegmentedArray::IterateIndex(int level, int& start, void** pIndex,
     }
     return NULL;
 }
-void* CFX_BaseSegmentedArray::Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::Iterate(bool (*callback)(void* param, void* pData), void* param) const
 {
     if (m_pIndex == NULL) {
         return NULL;
diff --git a/core/src/fxcrt/fx_basic_bstring.cpp b/core/src/fxcrt/fx_basic_bstring.cpp
index 5eeb33b049..47c1c5b6b2 100644
--- a/core/src/fxcrt/fx_basic_bstring.cpp
+++ b/core/src/fxcrt/fx_basic_bstring.cpp
@@ -1086,9 +1086,9 @@ FX_STRSIZE FX_ftoa(FX_FLOAT d, FX_CHAR* buf)
     if (d == 0.0f) {
         return 1;
     }
-    FX_BOOL bNegative = FALSE;
+    bool bNegative = false;
     if (d < 0) {
-        bNegative = TRUE;
+        bNegative = true;
         d = -d;
     }
     int scale = 1;
diff --git a/core/src/fxcrt/fx_basic_buffer.cpp b/core/src/fxcrt/fx_basic_buffer.cpp
index 9fc400e183..d7c1a1ad7b 100644
--- a/core/src/fxcrt/fx_basic_buffer.cpp
+++ b/core/src/fxcrt/fx_basic_buffer.cpp
@@ -321,7 +321,7 @@ CFX_ArchiveLoader::CFX_ArchiveLoader(const uint8_t* pData, FX_DWORD dwSize)
     m_LoadingPos = 0;
     m_LoadingSize = dwSize;
 }
-FX_BOOL CFX_ArchiveLoader::IsEOF()
+bool CFX_ArchiveLoader::IsEOF()
 {
     return m_LoadingPos >= m_LoadingSize;
 }
@@ -372,14 +372,14 @@ CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (CFX_WideString& str)
     str = CFX_WideString::FromUTF16LE((const unsigned short*)encoded.c_str(), encoded.GetLength());
     return *this;
 }
-FX_BOOL CFX_ArchiveLoader::Read(void* pBuf, FX_DWORD dwSize)
+bool CFX_ArchiveLoader::Read(void* pBuf, FX_DWORD dwSize)
 {
     if (m_LoadingPos + dwSize > m_LoadingSize) {
-        return FALSE;
+        return false;
     }
     FXSYS_memcpy(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);
     m_LoadingPos += dwSize;
-    return TRUE;
+    return true;
 }
 void CFX_BitStream::Init(const uint8_t* pData, FX_DWORD dwSize)
 {
@@ -441,9 +441,9 @@ void IFX_BufferArchive::Clear()
         m_pBuffer = NULL;
     }
 }
-FX_BOOL IFX_BufferArchive::Flush()
+bool IFX_BufferArchive::Flush()
 {
-    FX_BOOL bRet = DoWork(m_pBuffer, m_Length);
+    bool bRet = DoWork(m_pBuffer, m_Length);
     m_Length = 0;
     return bRet;
 }
@@ -488,7 +488,7 @@ int32_t IFX_BufferArchive::AppendString(const CFX_ByteStringC& lpsz)
 CFX_FileBufferArchive::CFX_FileBufferArchive(FX_STRSIZE size)
     : IFX_BufferArchive(size)
     , m_pFile(NULL)
-    , m_bTakeover(FALSE)
+    , m_bTakeover(false)
 {
 }
 CFX_FileBufferArchive::~CFX_FileBufferArchive()
@@ -501,58 +501,58 @@ void CFX_FileBufferArchive::Clear()
         m_pFile->Release();
     }
     m_pFile = NULL;
-    m_bTakeover = FALSE;
+    m_bTakeover = false;
     IFX_BufferArchive::Clear();
 }
-FX_BOOL CFX_FileBufferArchive::AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover )
+bool CFX_FileBufferArchive::AttachFile(IFX_StreamWrite *pFile, bool bTakeover )
 {
     if (!pFile) {
-        return FALSE;
+        return false;
     }
     if (m_pFile && m_bTakeover) {
         m_pFile->Release();
     }
     m_pFile = pFile;
     m_bTakeover = bTakeover;
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_FileBufferArchive::AttachFile(const FX_WCHAR* filename)
+bool CFX_FileBufferArchive::AttachFile(const FX_WCHAR* filename)
 {
     if (!filename) {
-        return FALSE;
+        return false;
     }
     if (m_pFile && m_bTakeover) {
         m_pFile->Release();
     }
     m_pFile = FX_CreateFileWrite(filename);
     if (!m_pFile) {
-        return FALSE;
+        return false;
     }
-    m_bTakeover = TRUE;
-    return TRUE;
+    m_bTakeover = true;
+    return true;
 }
-FX_BOOL CFX_FileBufferArchive::AttachFile(const FX_CHAR* filename)
+bool CFX_FileBufferArchive::AttachFile(const FX_CHAR* filename)
 {
     if (!filename) {
-        return FALSE;
+        return false;
     }
     if (m_pFile && m_bTakeover) {
         m_pFile->Release();
     }
     m_pFile = FX_CreateFileWrite(filename);
     if (!m_pFile) {
-        return FALSE;
+        return false;
     }
-    m_bTakeover = TRUE;
-    return TRUE;
+    m_bTakeover = true;
+    return true;
 }
-FX_BOOL CFX_FileBufferArchive::DoWork(const void* pBuf, size_t size)
+bool CFX_FileBufferArchive::DoWork(const void* pBuf, size_t size)
 {
     if (!m_pFile) {
-        return FALSE;
+        return false;
     }
     if (!pBuf || size < 1) {
-        return TRUE;
+        return true;
     }
     return m_pFile->WriteBlock(pBuf, size);
 }
diff --git a/core/src/fxcrt/fx_basic_coords.cpp b/core/src/fxcrt/fx_basic_coords.cpp
index 2e830809b8..22b9bd4715 100644
--- a/core/src/fxcrt/fx_basic_coords.cpp
+++ b/core/src/fxcrt/fx_basic_coords.cpp
@@ -45,15 +45,15 @@ void FX_RECT::Union(const FX_RECT& other_rect)
     bottom = bottom > other.bottom ? bottom : other.bottom;
     top = top < other.top ? top : other.top;
 }
-FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
+bool GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
                         FX_FLOAT& interlow, FX_FLOAT& interhigh)
 {
     if (low1 >= high2 || low2 >= high1) {
-        return FALSE;
+        return false;
     }
     interlow = low1 > low2 ? low1 : low2;
     interhigh = high1 > high2 ? high2 : high1;
-    return TRUE;
+    return true;
 }
 extern "C" int FXSYS_round(FX_FLOAT d)
 {
@@ -198,18 +198,18 @@ FX_RECT CFX_FloatRect::GetClosestRect() const
     rect.Normalize();
     return rect;
 }
-FX_BOOL CFX_FloatRect::Contains(const CFX_FloatRect& other_rect) const
+bool CFX_FloatRect::Contains(const CFX_FloatRect& other_rect) const
 {
     CFX_FloatRect n1 = *this;
     n1.Normalize();
     CFX_FloatRect n2 = other_rect;
     n2.Normalize();
     if (n2.left >= n1.left && n2.right <= n1.right && n2.bottom >= n1.bottom && n2.top <= n1.top) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CFX_FloatRect::Contains(FX_FLOAT x, FX_FLOAT y) const
+bool CFX_FloatRect::Contains(FX_FLOAT x, FX_FLOAT y) const
 {
     CFX_FloatRect n1 = *this;
     n1.Normalize();
@@ -299,13 +299,13 @@ static void FXCRT_Matrix_Concat(CFX_Matrix &m, const CFX_Matrix &m1, const CFX_M
     FX_FLOAT ff = m1.e * m2.b + m1.f * m2.d + m2.f;
     m.a = aa, m.b = bb, m.c = cc, m.d = dd, m.e = ee, m.f = ff;
 }
-void CFX_Matrix::Concat(FX_FLOAT a, FX_FLOAT b, FX_FLOAT c, FX_FLOAT d, FX_FLOAT e, FX_FLOAT f, FX_BOOL bPrepended)
+void CFX_Matrix::Concat(FX_FLOAT a, FX_FLOAT b, FX_FLOAT c, FX_FLOAT d, FX_FLOAT e, FX_FLOAT f, bool bPrepended)
 {
     CFX_Matrix m;
     m.Set(a, b, c, d, e, f);
     Concat(m, bPrepended);
 }
-void CFX_Matrix::Concat(const CFX_Matrix &m, FX_BOOL bPrepended)
+void CFX_Matrix::Concat(const CFX_Matrix &m, bool bPrepended)
 {
     if (bPrepended) {
         FXCRT_Matrix_Concat(*this, m, *this);
@@ -313,25 +313,25 @@ void CFX_Matrix::Concat(const CFX_Matrix &m, FX_BOOL bPrepended)
         FXCRT_Matrix_Concat(*this, *this, m);
     }
 }
-void CFX_Matrix::ConcatInverse(const CFX_Matrix& src, FX_BOOL bPrepended)
+void CFX_Matrix::ConcatInverse(const CFX_Matrix& src, bool bPrepended)
 {
     CFX_Matrix m;
     m.SetReverse(src);
     Concat(m, bPrepended);
 }
-FX_BOOL CFX_Matrix::IsInvertible() const
+bool CFX_Matrix::IsInvertible() const
 {
     return FXSYS_fabs(a * d - b * c) >= 0.0001f;
 }
-FX_BOOL CFX_Matrix::Is90Rotated() const
+bool CFX_Matrix::Is90Rotated() const
 {
     return FXSYS_fabs(a * 1000) < FXSYS_fabs(b) && FXSYS_fabs(d * 1000) < FXSYS_fabs(c);
 }
-FX_BOOL CFX_Matrix::IsScaled() const
+bool CFX_Matrix::IsScaled() const
 {
     return FXSYS_fabs(b * 1000) < FXSYS_fabs(a) && FXSYS_fabs(c * 1000) < FXSYS_fabs(d);
 }
-void CFX_Matrix::Translate(FX_FLOAT x, FX_FLOAT y, FX_BOOL bPrepended)
+void CFX_Matrix::Translate(FX_FLOAT x, FX_FLOAT y, bool bPrepended)
 {
     if (bPrepended) {
         e += x * a + y * c;
@@ -340,7 +340,7 @@ void CFX_Matrix::Translate(FX_FLOAT x, FX_FLOAT y, FX_BOOL bPrepended)
         e += x, f += y;
     }
 }
-void CFX_Matrix::Scale(FX_FLOAT sx, FX_FLOAT sy, FX_BOOL bPrepended)
+void CFX_Matrix::Scale(FX_FLOAT sx, FX_FLOAT sy, bool bPrepended)
 {
     a *= sx, d *= sy;
     if (bPrepended) {
@@ -353,7 +353,7 @@ void CFX_Matrix::Scale(FX_FLOAT sx, FX_FLOAT sy, FX_BOOL bPrepended)
         f *= sy;
     }
 }
-void CFX_Matrix::Rotate(FX_FLOAT fRadian, FX_BOOL bPrepended)
+void CFX_Matrix::Rotate(FX_FLOAT fRadian, bool bPrepended)
 {
     FX_FLOAT cosValue = FXSYS_cos(fRadian);
     FX_FLOAT sinValue = FXSYS_sin(fRadian);
@@ -365,13 +365,13 @@ void CFX_Matrix::Rotate(FX_FLOAT fRadian, FX_BOOL bPrepended)
         FXCRT_Matrix_Concat(*this, *this, m);
     }
 }
-void CFX_Matrix::RotateAt(FX_FLOAT fRadian, FX_FLOAT dx, FX_FLOAT dy, FX_BOOL bPrepended)
+void CFX_Matrix::RotateAt(FX_FLOAT fRadian, FX_FLOAT dx, FX_FLOAT dy, bool bPrepended)
 {
     Translate(dx, dy, bPrepended);
     Rotate(fRadian, bPrepended);
     Translate(-dx, -dy, bPrepended);
 }
-void CFX_Matrix::Shear(FX_FLOAT fAlphaRadian, FX_FLOAT fBetaRadian, FX_BOOL bPrepended)
+void CFX_Matrix::Shear(FX_FLOAT fAlphaRadian, FX_FLOAT fBetaRadian, bool bPrepended)
 {
     CFX_Matrix m;
     m.Set(1, FXSYS_tan(fAlphaRadian), FXSYS_tan(fBetaRadian), 1, 0, 0);
diff --git a/core/src/fxcrt/fx_basic_gcc.cpp b/core/src/fxcrt/fx_basic_gcc.cpp
index 2497c74a8e..562f741d41 100644
--- a/core/src/fxcrt/fx_basic_gcc.cpp
+++ b/core/src/fxcrt/fx_basic_gcc.cpp
@@ -12,12 +12,12 @@
 template <class T, class STR_T>
 T FXSYS_StrToInt(STR_T str)
 {
-    FX_BOOL neg = FALSE;
+    bool neg = false;
     if (str == NULL) {
         return 0;
     }
     if (*str == '-') {
-        neg = TRUE;
+        neg = true;
         str ++;
     }
     T num = 0;
diff --git a/core/src/fxcrt/fx_basic_maps.cpp b/core/src/fxcrt/fx_basic_maps.cpp
index e34acb088d..7de7b614f4 100644
--- a/core/src/fxcrt/fx_basic_maps.cpp
+++ b/core/src/fxcrt/fx_basic_maps.cpp
@@ -69,15 +69,15 @@ void CFX_MapPtrToPtr::GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void
     rKey = pAssocRet->key;
     rValue = pAssocRet->value;
 }
-FX_BOOL CFX_MapPtrToPtr::Lookup(void* key, void*& rValue) const
+bool CFX_MapPtrToPtr::Lookup(void* key, void*& rValue) const
 {
     FX_DWORD nHash;
     CAssoc* pAssoc = GetAssocAt(key, nHash);
     if (pAssoc == NULL) {
-        return FALSE;
+        return false;
     }
     rValue = pAssoc->value;
-    return TRUE;
+    return true;
 }
 void* CFX_MapPtrToPtr::GetValueAt(void* key) const
 {
@@ -140,7 +140,7 @@ CFX_MapPtrToPtr::NewAssoc()
     return pAssoc;
 }
 void CFX_MapPtrToPtr::InitHashTable(
-    FX_DWORD nHashSize, FX_BOOL bAllocNow)
+    FX_DWORD nHashSize, bool bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
@@ -153,10 +153,10 @@ void CFX_MapPtrToPtr::InitHashTable(
     }
     m_nHashTableSize = nHashSize;
 }
-FX_BOOL CFX_MapPtrToPtr::RemoveKey(void* key)
+bool CFX_MapPtrToPtr::RemoveKey(void* key)
 {
     if (m_pHashTable == NULL) {
-        return FALSE;
+        return false;
     }
     CAssoc** ppAssocPrev;
     ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];
@@ -165,11 +165,11 @@ FX_BOOL CFX_MapPtrToPtr::RemoveKey(void* key)
         if (pAssoc->key == key) {
             *ppAssocPrev = pAssoc->pNext;
             FreeAssoc(pAssoc);
-            return TRUE;
+            return true;
         }
         ppAssocPrev = &pAssoc->pNext;
     }
-    return FALSE;
+    return false;
 }
 void CFX_MapPtrToPtr::FreeAssoc(CFX_MapPtrToPtr::CAssoc* pAssoc)
 {
@@ -325,18 +325,18 @@ CFX_MapByteStringToPtr::GetAssocAt(const CFX_ByteStringC& key, FX_DWORD& nHash)
     }
     return NULL;
 }
-FX_BOOL CFX_MapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
+bool CFX_MapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
 {
     FX_DWORD nHash;
     CAssoc* pAssoc = GetAssocAt(key, nHash);
     if (pAssoc == NULL) {
-        return FALSE;
+        return false;
     }
     rValue = pAssoc->value;
-    return TRUE;
+    return true;
 }
 void CFX_MapByteStringToPtr::InitHashTable(
-    FX_DWORD nHashSize, FX_BOOL bAllocNow)
+    FX_DWORD nHashSize, bool bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
@@ -359,10 +359,10 @@ inline FX_DWORD CFX_MapByteStringToPtr::HashKey(const CFX_ByteStringC& key) cons
     }
     return nHash;
 }
-FX_BOOL CFX_MapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key)
+bool CFX_MapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key)
 {
     if (m_pHashTable == NULL) {
-        return FALSE;
+        return false;
     }
     CAssoc** ppAssocPrev;
     ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];
@@ -371,11 +371,11 @@ FX_BOOL CFX_MapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key)
         if (pAssoc->key == key) {
             *ppAssocPrev = pAssoc->pNext;
             FreeAssoc(pAssoc);
-            return TRUE;
+            return true;
         }
         ppAssocPrev = &pAssoc->pNext;
     }
-    return FALSE;
+    return false;
 }
 struct _CompactString {
     uint8_t		m_CompactLen;
@@ -390,16 +390,16 @@ static void _CompactStringRelease(_CompactString* pCompact)
         FX_Free(pCompact->m_pBuffer);
     }
 }
-static FX_BOOL _CompactStringSame(_CompactString* pCompact, const uint8_t* pStr, int len)
+static bool _CompactStringSame(_CompactString* pCompact, const uint8_t* pStr, int len)
 {
     if (len < sizeof(_CompactString)) {
         if (pCompact->m_CompactLen != len) {
-            return FALSE;
+            return false;
         }
         return FXSYS_memcmp(&pCompact->m_LenHigh, pStr, len) == 0;
     }
     if (pCompact->m_CompactLen != 0xff || pCompact->m_LenHigh * 256 + pCompact->m_LenLow != len) {
-        return FALSE;
+        return false;
     }
     return FXSYS_memcmp(pCompact->m_pBuffer, pStr, len) == 0;
 }
@@ -497,18 +497,18 @@ void* CFX_CMapByteStringToPtr::GetNextValue(FX_POSITION& rNextPosition) const
     rNextPosition = NULL;
     return rValue;
 }
-FX_BOOL _CMapLookupCallback(void* param, void* pData)
+bool _CMapLookupCallback(void* param, void* pData)
 {
     return !_CompactStringSame((_CompactString*)pData, ((CFX_ByteStringC*)param)->GetPtr(), ((CFX_ByteStringC*)param)->GetLength());
 }
-FX_BOOL CFX_CMapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
+bool CFX_CMapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
 {
     void* p = m_Buffer.Iterate(_CMapLookupCallback, (void*)&key);
     if (!p) {
-        return FALSE;
+        return false;
     }
     rValue = *(void**)((_CompactString*)p + 1);
-    return TRUE;
+    return true;
 }
 void CFX_CMapByteStringToPtr::SetAt(const CFX_ByteStringC& key, void* value)
 {
@@ -579,15 +579,15 @@ struct _DWordPair {
     FX_DWORD key;
     FX_DWORD value;
 };
-FX_BOOL CFX_CMapDWordToDWord::Lookup(FX_DWORD key, FX_DWORD& value) const
+bool CFX_CMapDWordToDWord::Lookup(FX_DWORD key, FX_DWORD& value) const
 {
     void* pResult = FXSYS_bsearch(&key, m_Buffer.GetBuffer(), m_Buffer.GetSize() / sizeof(_DWordPair),
                                       sizeof(_DWordPair), _CompareDWord);
     if (pResult == NULL) {
-        return FALSE;
+        return false;
     }
     value = ((FX_DWORD*)pResult)[1];
-    return TRUE;
+    return true;
 }
 FX_POSITION CFX_CMapDWordToDWord::GetStartPosition() const
 {
diff --git a/core/src/fxcrt/fx_basic_util.cpp b/core/src/fxcrt/fx_basic_util.cpp
index 26eeacce1b..1343374111 100644
--- a/core/src/fxcrt/fx_basic_util.cpp
+++ b/core/src/fxcrt/fx_basic_util.cpp
@@ -26,7 +26,7 @@ void FX_PRIVATEDATA::FreeData()
         m_pCallback(m_pData);
     }
 }
-void CFX_PrivateData::AddData(void* pModuleId, void* pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct)
+void CFX_PrivateData::AddData(void* pModuleId, void* pData, PD_CALLBACK_FREEDATA callback, bool bSelfDestruct)
 {
     if (pModuleId == NULL) {
         return;
@@ -46,26 +46,26 @@ void CFX_PrivateData::AddData(void* pModuleId, void* pData, PD_CALLBACK_FREEDATA
 }
 void CFX_PrivateData::SetPrivateData(void* pModuleId, void* pData, PD_CALLBACK_FREEDATA callback)
 {
-    AddData(pModuleId, pData, callback, FALSE);
+    AddData(pModuleId, pData, callback, false);
 }
 void CFX_PrivateData::SetPrivateObj(void* pModuleId, CFX_DestructObject* pObj)
 {
-    AddData(pModuleId, pObj, NULL, TRUE);
+    AddData(pModuleId, pObj, NULL, true);
 }
-FX_BOOL CFX_PrivateData::RemovePrivateData(void* pModuleId)
+bool CFX_PrivateData::RemovePrivateData(void* pModuleId)
 {
     if (pModuleId == NULL) {
-        return FALSE;
+        return false;
     }
     FX_PRIVATEDATA* pList = m_DataList.GetData();
     int count = m_DataList.GetSize();
     for (int i = 0; i < count; i ++) {
         if (pList[i].m_pModuleId == pModuleId) {
             m_DataList.RemoveAt(i);
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 void* CFX_PrivateData::GetPrivateData(void* pModuleId)
 {
@@ -90,18 +90,18 @@ void CFX_PrivateData::ClearAll()
     }
     m_DataList.RemoveAll();
 }
-void FX_atonum(const CFX_ByteStringC& strc, FX_BOOL& bInteger, void* pData)
+void FX_atonum(const CFX_ByteStringC& strc, bool& bInteger, void* pData)
 {
     if (FXSYS_memchr(strc.GetPtr(), '.', strc.GetLength()) == NULL) {
-        bInteger = TRUE;
+        bInteger = true;
         int cc = 0, integer = 0;
         const FX_CHAR* str = strc.GetCStr();
         int len = strc.GetLength();
-        FX_BOOL bNegative = FALSE;
+        bool bNegative = false;
         if (str[0] == '+') {
             cc++;
         } else if (str[0] == '-') {
-            bNegative = TRUE;
+            bNegative = true;
             cc++;
         }
         while (cc < len) {
@@ -119,7 +119,7 @@ void FX_atonum(const CFX_ByteStringC& strc, FX_BOOL& bInteger, void* pData)
         }
         *(int*)pData = integer;
     } else {
-        bInteger = FALSE;
+        bInteger = false;
         *(FX_FLOAT*)pData = FX_atof(strc);
     }
 }
@@ -129,13 +129,13 @@ FX_FLOAT FX_atof(const CFX_ByteStringC& strc)
         return 0.0;
     }
     int cc = 0;
-    FX_BOOL bNegative = FALSE;
+    bool bNegative = false;
     const FX_CHAR* str = strc.GetCStr();
     int len = strc.GetLength();
     if (str[0] == '+') {
         cc++;
     } else if (str[0] == '-') {
-        bNegative = TRUE;
+        bNegative = true;
         cc++;
     }
     while (cc < len) {
@@ -187,13 +187,13 @@ void FXSYS_vsnprintf(char *str, size_t size, const char* fmt, va_list ap)
 }
 #endif  // _FXM_PLATFORM_WINDOWS_ && _MSC_VER < 1900
 
-static FX_BOOL FX_IsDigit(uint8_t ch)
+static bool FX_IsDigit(uint8_t ch)
 {
-    return (ch >= '0' && ch <= '9') ? TRUE : FALSE;
+    return (ch >= '0' && ch <= '9') ? true : false;
 }
-static FX_BOOL FX_IsXDigit(uint8_t ch)
+static bool FX_IsXDigit(uint8_t ch)
 {
-    return (FX_IsDigit(ch) || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) ? TRUE : FALSE;
+    return (FX_IsDigit(ch) || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) ? true : false;
 }
 static uint8_t FX_MakeUpper(uint8_t ch)
 {
@@ -299,7 +299,7 @@ class CFindFileData
 public:
     virtual ~CFindFileData() {}
     HANDLE				m_Handle;
-    FX_BOOL				m_bEnd;
+    bool				m_bEnd;
 };
 class CFindFileDataA : public CFindFileData
 {
@@ -332,7 +332,7 @@ void* FX_OpenFolder(const FX_CHAR* path)
         delete pData;
         return NULL;
     }
-    pData->m_bEnd = FALSE;
+    pData->m_bEnd = false;
     return pData;
 #else
     DIR* dir = opendir(path);
@@ -352,82 +352,82 @@ void* FX_OpenFolder(const FX_WCHAR* path)
         delete pData;
         return NULL;
     }
-    pData->m_bEnd = FALSE;
+    pData->m_bEnd = false;
     return pData;
 #else
     DIR* dir = opendir(CFX_ByteString::FromUnicode(path));
     return dir;
 #endif
 }
-FX_BOOL FX_GetNextFile(void* handle, CFX_ByteString& filename, FX_BOOL& bFolder)
+bool FX_GetNextFile(void* handle, CFX_ByteString& filename, bool& bFolder)
 {
     if (handle == NULL) {
-        return FALSE;
+        return false;
     }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 #ifndef _WIN32_WCE
     CFindFileDataA* pData = (CFindFileDataA*)handle;
     if (pData->m_bEnd) {
-        return FALSE;
+        return false;
     }
     filename = pData->m_FindData.cFileName;
     bFolder = pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
     if (!FindNextFileA(pData->m_Handle, &pData->m_FindData)) {
-        pData->m_bEnd = TRUE;
+        pData->m_bEnd = true;
     }
-    return TRUE;
+    return true;
 #else
     CFindFileDataW* pData = (CFindFileDataW*)handle;
     if (pData->m_bEnd) {
-        return FALSE;
+        return false;
     }
     filename = CFX_ByteString::FromUnicode(pData->m_FindData.cFileName);
     bFolder = pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
     if (!FindNextFileW(pData->m_Handle, &pData->m_FindData)) {
-        pData->m_bEnd = TRUE;
+        pData->m_bEnd = true;
     }
-    return TRUE;
+    return true;
 #endif
 #elif defined(__native_client__)
     abort();
-    return FALSE;
+    return false;
 #else
     struct dirent *de = readdir((DIR*)handle);
     if (de == NULL) {
-        return FALSE;
+        return false;
     }
     filename = de->d_name;
     bFolder = de->d_type == DT_DIR;
-    return TRUE;
+    return true;
 #endif
 }
-FX_BOOL FX_GetNextFile(void* handle, CFX_WideString& filename, FX_BOOL& bFolder)
+bool FX_GetNextFile(void* handle, CFX_WideString& filename, bool& bFolder)
 {
     if (handle == NULL) {
-        return FALSE;
+        return false;
     }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     CFindFileDataW* pData = (CFindFileDataW*)handle;
     if (pData->m_bEnd) {
-        return FALSE;
+        return false;
     }
     filename = pData->m_FindData.cFileName;
     bFolder = pData->m_FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
     if (!FindNextFileW(pData->m_Handle, &pData->m_FindData)) {
-        pData->m_bEnd = TRUE;
+        pData->m_bEnd = true;
     }
-    return TRUE;
+    return true;
 #elif defined(__native_client__)
     abort();
-    return FALSE;
+    return false;
 #else
     struct dirent *de = readdir((DIR*)handle);
     if (de == NULL) {
-        return FALSE;
+        return false;
     }
     filename = CFX_WideString::FromLocal(de->d_name);
     bFolder = de->d_type == DT_DIR;
-    return TRUE;
+    return true;
 #endif
 }
 void FX_CloseFolder(void* handle)
diff --git a/core/src/fxcrt/fx_basic_wstring.cpp b/core/src/fxcrt/fx_basic_wstring.cpp
index b6b595588d..bb236ac21b 100644
--- a/core/src/fxcrt/fx_basic_wstring.cpp
+++ b/core/src/fxcrt/fx_basic_wstring.cpp
@@ -980,11 +980,11 @@ FX_FLOAT FX_wtof(const FX_WCHAR* str, int len)
         return 0.0;
     }
     int cc = 0;
-    FX_BOOL bNegative = FALSE;
+    bool bNegative = false;
     if (str[0] == '+') {
         cc++;
     } else if (str[0] == '-') {
-        bNegative = TRUE;
+        bNegative = true;
         cc++;
     }
     int integer = 0;
diff --git a/core/src/fxcrt/fx_extension.cpp b/core/src/fxcrt/fx_extension.cpp
index 4662e8f893..fe6f29f6a2 100644
--- a/core/src/fxcrt/fx_extension.cpp
+++ b/core/src/fxcrt/fx_extension.cpp
@@ -72,12 +72,12 @@ size_t FX_File_WritePos(FX_HFILE hFile, const void* pBuffer, size_t szBuffer, FX
     FXSYS_assert(hFile != NULL);
     return ((IFXCRT_FileAccess*)hFile)->WritePos(pBuffer, szBuffer, pos);
 }
-FX_BOOL FX_File_Flush(FX_HFILE hFile)
+bool FX_File_Flush(FX_HFILE hFile)
 {
     FXSYS_assert(hFile != NULL);
     return ((IFXCRT_FileAccess*)hFile)->Flush();
 }
-FX_BOOL FX_File_Truncate(FX_HFILE hFile, FX_FILESIZE szFile)
+bool FX_File_Truncate(FX_HFILE hFile, FX_FILESIZE szFile)
 {
     FXSYS_assert(hFile != NULL);
     return ((IFXCRT_FileAccess*)hFile)->Truncate(szFile);
@@ -122,11 +122,11 @@ IFX_FileRead* FX_CreateFileRead(const FX_WCHAR* filename)
 {
     return FX_CreateFileStream(filename, FX_FILEMODE_ReadOnly);
 }
-IFX_MemoryStream* FX_CreateMemoryStream(uint8_t* pBuffer, size_t dwSize, FX_BOOL bTakeOver)
+IFX_MemoryStream* FX_CreateMemoryStream(uint8_t* pBuffer, size_t dwSize, bool bTakeOver)
 {
     return new CFX_MemoryStream(pBuffer, dwSize, bTakeOver);
 }
-IFX_MemoryStream* FX_CreateMemoryStream(FX_BOOL bConsecutive)
+IFX_MemoryStream* FX_CreateMemoryStream(bool bConsecutive)
 {
     return new CFX_MemoryStream(bConsecutive);
 }
@@ -160,10 +160,10 @@ FX_FLOAT FXSYS_wcstof(const FX_WCHAR* pwsStr, int32_t iLength, int32_t *pUsedLen
         return 0.0f;
     }
     int32_t iUsedLen = 0;
-    FX_BOOL bNegtive = FALSE;
+    bool bNegtive = false;
     switch (pwsStr[iUsedLen]) {
         case '-':
-            bNegtive = TRUE;
+            bNegtive = true;
         case '+':
             iUsedLen++;
             break;
@@ -230,7 +230,7 @@ int32_t FXSYS_strnicmp(const FX_CHAR* s1, const FX_CHAR* s2, size_t count)
     }
     return ch1 - ch2;
 }
-FX_DWORD FX_HashCode_String_GetA(const FX_CHAR* pStr, int32_t iLength, FX_BOOL bIgnoreCase)
+FX_DWORD FX_HashCode_String_GetA(const FX_CHAR* pStr, int32_t iLength, bool bIgnoreCase)
 {
     FXSYS_assert(pStr != NULL);
     if (iLength < 0) {
@@ -249,7 +249,7 @@ FX_DWORD FX_HashCode_String_GetA(const FX_CHAR* pStr, int32_t iLength, FX_BOOL b
     }
     return dwHashCode;
 }
-FX_DWORD FX_HashCode_String_GetW(const FX_WCHAR* pStr, int32_t iLength, FX_BOOL bIgnoreCase)
+FX_DWORD FX_HashCode_String_GetW(const FX_WCHAR* pStr, int32_t iLength, bool bIgnoreCase)
 {
     FXSYS_assert(pStr != NULL);
     if (iLength < 0) {
@@ -283,7 +283,7 @@ void* FX_Random_MT_Start(FX_DWORD dwSeed)
     for (i = 1; i < MT_N; i ++) {
         pBuf[i] = (1812433253UL * (pBuf[i - 1] ^ (pBuf[i - 1] >> 30)) + i);
     }
-    pContext->bHaveSeed = TRUE;
+    pContext->bHaveSeed = true;
     return pContext;
 }
 FX_DWORD FX_Random_MT_Generate(void* pContext)
@@ -347,8 +347,8 @@ void FX_Random_GenerateBase(FX_DWORD* pBuffer, int32_t iCount)
     do {
         ::GetSystemTime(&st2);
     } while (FXSYS_memcmp(&st1, &st2, sizeof(SYSTEMTIME)) == 0);
-    FX_DWORD dwHash1 = FX_HashCode_String_GetA((const FX_CHAR*)&st1, sizeof(st1), TRUE);
-    FX_DWORD dwHash2 = FX_HashCode_String_GetA((const FX_CHAR*)&st2, sizeof(st2), TRUE);
+    FX_DWORD dwHash1 = FX_HashCode_String_GetA((const FX_CHAR*)&st1, sizeof(st1), true);
+    FX_DWORD dwHash2 = FX_HashCode_String_GetA((const FX_CHAR*)&st2, sizeof(st2), true);
     ::srand((dwHash1 << 16) | (FX_DWORD)dwHash2);
 #else
     time_t tmLast = time(NULL), tmCur;
@@ -360,15 +360,15 @@ void FX_Random_GenerateBase(FX_DWORD* pBuffer, int32_t iCount)
     }
 }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-FX_BOOL FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount)
+bool FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount)
 {
     HCRYPTPROV hCP = NULL;
     if (!::CryptAcquireContext(&hCP, NULL, NULL, PROV_RSA_FULL, 0) || hCP == NULL) {
-        return FALSE;
+        return false;
     }
     ::CryptGenRandom(hCP, iCount * sizeof(FX_DWORD), (uint8_t*)pBuffer);
     ::CryptReleaseContext(hCP, 0);
-    return TRUE;
+    return true;
 }
 #endif
 void FX_Random_GenerateCrypto(FX_DWORD* pBuffer, int32_t iCount)
diff --git a/core/src/fxcrt/fx_unicode.cpp b/core/src/fxcrt/fx_unicode.cpp
index d66a58a9b3..1d63da93aa 100644
--- a/core/src/fxcrt/fx_unicode.cpp
+++ b/core/src/fxcrt/fx_unicode.cpp
@@ -13,27 +13,27 @@ FX_DWORD FX_GetUnicodeProperties(FX_WCHAR wch)
 {
     return gs_FX_TextLayout_CodeProperties[(FX_WORD)wch];
 }
-FX_BOOL FX_IsCtrlCode(FX_WCHAR ch)
+bool FX_IsCtrlCode(FX_WCHAR ch)
 {
     FX_DWORD dwRet = (gs_FX_TextLayout_CodeProperties[(FX_WORD)ch] & FX_CHARTYPEBITSMASK);
     return dwRet == FX_CHARTYPE_Tab || dwRet == FX_CHARTYPE_Control;
 }
-FX_BOOL FX_IsRotationCode(FX_WCHAR ch)
+bool FX_IsRotationCode(FX_WCHAR ch)
 {
     return (gs_FX_TextLayout_CodeProperties[(FX_WORD)ch] & 0x8000) != 0;
 }
-FX_BOOL FX_IsCombinationChar(FX_WCHAR wch)
+bool FX_IsCombinationChar(FX_WCHAR wch)
 {
     FX_DWORD dwProps = (gs_FX_TextLayout_CodeProperties[(FX_WORD)wch] & FX_CHARTYPEBITSMASK);
     return dwProps == FX_CHARTYPE_Combination;
 }
-FX_BOOL	FX_IsBidiChar(FX_WCHAR wch)
+bool	FX_IsBidiChar(FX_WCHAR wch)
 {
     FX_DWORD dwProps = gs_FX_TextLayout_CodeProperties[(FX_WORD)wch];
     int32_t iBidiCls = (dwProps & FX_BIDICLASSBITSMASK) >> FX_BIDICLASSBITS;
     return (FX_BIDICLASS_R == iBidiCls || FX_BIDICLASS_AL == iBidiCls);
 }
-FX_WCHAR FX_GetMirrorChar(FX_WCHAR wch, FX_BOOL bRTL, FX_BOOL bVertical)
+FX_WCHAR FX_GetMirrorChar(FX_WCHAR wch, bool bRTL, bool bVertical)
 {
     FX_DWORD dwProps = gs_FX_TextLayout_CodeProperties[(FX_WORD)wch];
     FX_DWORD dwTemp = (dwProps & 0xFF800000);
@@ -49,7 +49,7 @@ FX_WCHAR FX_GetMirrorChar(FX_WCHAR wch, FX_BOOL bRTL, FX_BOOL bVertical)
     }
     return wch;
 }
-FX_WCHAR FX_GetMirrorChar(FX_WCHAR wch, FX_DWORD dwProps, FX_BOOL bRTL, FX_BOOL bVertical)
+FX_WCHAR FX_GetMirrorChar(FX_WCHAR wch, FX_DWORD dwProps, bool bRTL, bool bVertical)
 {
     FX_DWORD dwTemp = (dwProps & 0xFF800000);
     if (bRTL && dwTemp < 0xFF800000) {
diff --git a/core/src/fxcrt/fx_xml_parser.cpp b/core/src/fxcrt/fx_xml_parser.cpp
index dcf91d1a97..73695a6ec8 100644
--- a/core/src/fxcrt/fx_xml_parser.cpp
+++ b/core/src/fxcrt/fx_xml_parser.cpp
@@ -12,34 +12,34 @@ CXML_Parser::~CXML_Parser()
         m_pDataAcc->Release();
     }
 }
-FX_BOOL CXML_Parser::Init(uint8_t* pBuffer, size_t size)
+bool CXML_Parser::Init(uint8_t* pBuffer, size_t size)
 {
     m_pDataAcc = new CXML_DataBufAcc(pBuffer, size);
-    return Init(TRUE);
+    return Init(true);
 }
-FX_BOOL CXML_Parser::Init(IFX_FileRead *pFileRead)
+bool CXML_Parser::Init(IFX_FileRead *pFileRead)
 {
     m_pDataAcc = new CXML_DataStmAcc(pFileRead);
-    return Init(TRUE);
+    return Init(true);
 }
-FX_BOOL CXML_Parser::Init(IFX_BufferRead *pBuffer)
+bool CXML_Parser::Init(IFX_BufferRead *pBuffer)
 {
     if (!pBuffer) {
-        return FALSE;
+        return false;
     }
     m_pDataAcc = pBuffer;
-    return Init(FALSE);
+    return Init(false);
 }
-FX_BOOL CXML_Parser::Init(FX_BOOL bOwndedStream)
+bool CXML_Parser::Init(bool bOwndedStream)
 {
     m_bOwnedStream = bOwndedStream;
     m_nOffset = 0;
     return ReadNextBlock();
 }
-FX_BOOL CXML_Parser::ReadNextBlock()
+bool CXML_Parser::ReadNextBlock()
 {
     if (!m_pDataAcc->ReadNextBlock()) {
-        return FALSE;
+        return false;
     }
     m_pBuffer = m_pDataAcc->GetBlockBuffer();
     m_dwBufferSize = m_pDataAcc->GetBlockSize();
@@ -47,10 +47,10 @@ FX_BOOL CXML_Parser::ReadNextBlock()
     m_dwIndex = 0;
     return m_dwBufferSize > 0;
 }
-FX_BOOL CXML_Parser::IsEOF()
+bool CXML_Parser::IsEOF()
 {
     if (!m_pDataAcc->IsEOF()) {
-        return FALSE;
+        return false;
     }
     return m_dwIndex >= m_dwBufferSize;
 }
@@ -82,27 +82,27 @@ uint8_t g_FXCRT_XML_ByteTypes[256] = {
     0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A,
     0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x01, 0x01,
 };
-FX_BOOL g_FXCRT_XML_IsWhiteSpace(uint8_t ch)
+bool g_FXCRT_XML_IsWhiteSpace(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_SpaceChar) != 0;
 }
-FX_BOOL g_FXCRT_XML_IsLetter(uint8_t ch)
+bool g_FXCRT_XML_IsLetter(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_Letter) != 0;
 }
-FX_BOOL g_FXCRT_XML_IsDigital(uint8_t ch)
+bool g_FXCRT_XML_IsDigital(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_Digital) != 0;
 }
-FX_BOOL g_FXCRT_XML_IsNameIntro(uint8_t ch)
+bool g_FXCRT_XML_IsNameIntro(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_NameIntro) != 0;
 }
-FX_BOOL g_FXCRT_XML_IsNameChar(uint8_t ch)
+bool g_FXCRT_XML_IsNameChar(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_NameChar) != 0;
 }
-FX_BOOL g_FXCRT_XML_IsHexChar(uint8_t ch)
+bool g_FXCRT_XML_IsHexChar(uint8_t ch)
 {
     return (g_FXCRT_XML_ByteTypes[ch] & FXCRTM_XML_CHARTYPE_HexChar) != 0;
 }
@@ -310,13 +310,13 @@ void CXML_Parser::GetAttrValue(CFX_WideString &value)
     } while (ReadNextBlock());
     value = decoder.GetResult();
 }
-void CXML_Parser::GetTagName(CFX_ByteString &space, CFX_ByteString &name, FX_BOOL &bEndTag, FX_BOOL bStartTag)
+void CXML_Parser::GetTagName(CFX_ByteString &space, CFX_ByteString &name, bool &bEndTag, bool bStartTag)
 {
     m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
     if (IsEOF()) {
         return;
     }
-    bEndTag = FALSE;
+    bEndTag = false;
     uint8_t ch;
     int32_t iState = bStartTag ? 1 : 0;
     do {
@@ -345,10 +345,10 @@ void CXML_Parser::GetTagName(CFX_ByteString &space, CFX_ByteString &name, FX_BOO
                     if (ch == '/') {
                         m_dwIndex ++;
                         GetName(space, name);
-                        bEndTag = TRUE;
+                        bEndTag = true;
                     } else {
                         GetName(space, name);
-                        bEndTag = FALSE;
+                        bEndTag = false;
                     }
                     return;
             }
@@ -359,14 +359,14 @@ void CXML_Parser::GetTagName(CFX_ByteString &space, CFX_ByteString &name, FX_BOO
         }
     } while (ReadNextBlock());
 }
-CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, FX_BOOL bStartTag)
+CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, bool bStartTag)
 {
     m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
     if (IsEOF()) {
         return NULL;
     }
     CFX_ByteString tag_name, tag_space;
-    FX_BOOL bEndTag;
+    bool bEndTag;
     GetTagName(tag_space, tag_name, bEndTag, bStartTag);
     if (tag_name.IsEmpty() || bEndTag) {
         return NULL;
@@ -427,7 +427,7 @@ CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, FX_BOOL bStartTag
     }
     CFX_UTF8Decoder decoder;
     CFX_WideTextBuf content;
-    FX_BOOL bCDATA = FALSE;
+    bool bCDATA = false;
     int32_t iState = 0;
     do {
         while (m_dwIndex < m_dwBufferSize) {
@@ -465,10 +465,10 @@ CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, FX_BOOL bStartTag
                         InsertContentSegment(bCDATA, dataStr, pElement);
                         content.Clear();
                         decoder.Clear();
-                        bCDATA = FALSE;
+                        bCDATA = false;
                         iState = 0;
                         m_dwIndex --;
-                        CXML_Element* pSubElement = ParseElement(pElement, TRUE);
+                        CXML_Element* pSubElement = ParseElement(pElement, true);
                         if (pSubElement == NULL) {
                             break;
                         }
@@ -509,10 +509,10 @@ CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, FX_BOOL bStartTag
     InsertContentSegment(bCDATA, dataStr, pElement);
     content.Clear();
     decoder.Clear();
-    bCDATA = FALSE;
+    bCDATA = false;
     return pElement;
 }
-void CXML_Parser::InsertContentSegment(FX_BOOL bCDATA, const CFX_WideStringC& content, CXML_Element* pElement)
+void CXML_Parser::InsertContentSegment(bool bCDATA, const CFX_WideStringC& content, CXML_Element* pElement)
 {
     if (content.IsEmpty()) {
         return;
@@ -522,16 +522,16 @@ void CXML_Parser::InsertContentSegment(FX_BOOL bCDATA, const CFX_WideStringC& co
     pElement->m_Children.Add((void*)CXML_Element::Content);
     pElement->m_Children.Add(pContent);
 }
-static CXML_Element* XML_ContinueParse(CXML_Parser &parser, FX_BOOL bSaveSpaceChars, FX_FILESIZE* pParsedSize)
+static CXML_Element* XML_ContinueParse(CXML_Parser &parser, bool bSaveSpaceChars, FX_FILESIZE* pParsedSize)
 {
     parser.m_bSaveSpaceChars = bSaveSpaceChars;
-    CXML_Element* pElement = parser.ParseElement(NULL, FALSE);
+    CXML_Element* pElement = parser.ParseElement(NULL, false);
     if (pParsedSize) {
         *pParsedSize = parser.m_nOffset;
     }
     return pElement;
 }
-CXML_Element* CXML_Element::Parse(const void* pBuffer, size_t size, FX_BOOL bSaveSpaceChars, FX_FILESIZE* pParsedSize)
+CXML_Element* CXML_Element::Parse(const void* pBuffer, size_t size, bool bSaveSpaceChars, FX_FILESIZE* pParsedSize)
 {
     CXML_Parser parser;
     if (!parser.Init((uint8_t*)pBuffer, size)) {
@@ -539,7 +539,7 @@ CXML_Element* CXML_Element::Parse(const void* pBuffer, size_t size, FX_BOOL bSav
     }
     return XML_ContinueParse(parser, bSaveSpaceChars, pParsedSize);
 }
-CXML_Element* CXML_Element::Parse(IFX_FileRead *pFile, FX_BOOL bSaveSpaceChars, FX_FILESIZE* pParsedSize)
+CXML_Element* CXML_Element::Parse(IFX_FileRead *pFile, bool bSaveSpaceChars, FX_FILESIZE* pParsedSize)
 {
     CXML_Parser parser;
     if (!parser.Init(pFile)) {
@@ -547,7 +547,7 @@ CXML_Element* CXML_Element::Parse(IFX_FileRead *pFile, FX_BOOL bSaveSpaceChars,
     }
     return XML_ContinueParse(parser, bSaveSpaceChars, pParsedSize);
 }
-CXML_Element* CXML_Element::Parse(IFX_BufferRead *pBuffer, FX_BOOL bSaveSpaceChars, FX_FILESIZE* pParsedSize)
+CXML_Element* CXML_Element::Parse(IFX_BufferRead *pBuffer, bool bSaveSpaceChars, FX_FILESIZE* pParsedSize)
 {
     CXML_Parser parser;
     if (!parser.Init(pBuffer)) {
@@ -600,7 +600,7 @@ void CXML_Element::RemoveChildren()
     }
     m_Children.RemoveAll();
 }
-CFX_ByteString CXML_Element::GetTagName(FX_BOOL bQualified) const
+CFX_ByteString CXML_Element::GetTagName(bool bQualified) const
 {
     if (!bQualified || m_QSpaceName.IsEmpty()) {
         return m_TagName;
@@ -610,7 +610,7 @@ CFX_ByteString CXML_Element::GetTagName(FX_BOOL bQualified) const
     bsTag += m_TagName;
     return bsTag;
 }
-CFX_ByteString CXML_Element::GetNamespace(FX_BOOL bQualified) const
+CFX_ByteString CXML_Element::GetNamespace(bool bQualified) const
 {
     if (bQualified) {
         return m_QSpaceName;
@@ -644,61 +644,61 @@ void CXML_Element::GetAttrByIndex(int index, CFX_ByteString& space, CFX_ByteStri
     name = item.m_AttrName;
     value = item.m_Value;
 }
-FX_BOOL CXML_Element::HasAttr(const CFX_ByteStringC& name) const
+bool CXML_Element::HasAttr(const CFX_ByteStringC& name) const
 {
     CFX_ByteStringC bsSpace, bsName;
     FX_XML_SplitQualifiedName(name, bsSpace, bsName);
     return m_AttrMap.Lookup(bsSpace, bsName) != NULL;
 }
-FX_BOOL CXML_Element::GetAttrValue(const CFX_ByteStringC& name, CFX_WideString& attribute) const
+bool CXML_Element::GetAttrValue(const CFX_ByteStringC& name, CFX_WideString& attribute) const
 {
     CFX_ByteStringC bsSpace, bsName;
     FX_XML_SplitQualifiedName(name, bsSpace, bsName);
     return GetAttrValue(bsSpace, bsName, attribute);
 }
-FX_BOOL CXML_Element::GetAttrValue(const CFX_ByteStringC& space, const CFX_ByteStringC& name, CFX_WideString& attribute) const
+bool CXML_Element::GetAttrValue(const CFX_ByteStringC& space, const CFX_ByteStringC& name, CFX_WideString& attribute) const
 {
     const CFX_WideString* pValue = m_AttrMap.Lookup(space, name);
     if (pValue) {
         attribute = *pValue;
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CXML_Element::GetAttrInteger(const CFX_ByteStringC& name, int& attribute) const
+bool CXML_Element::GetAttrInteger(const CFX_ByteStringC& name, int& attribute) const
 {
     CFX_ByteStringC bsSpace, bsName;
     FX_XML_SplitQualifiedName(name, bsSpace, bsName);
     const CFX_WideString* pwsValue = m_AttrMap.Lookup(bsSpace, bsName);
     if (pwsValue) {
         attribute = pwsValue->GetInteger();
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL	CXML_Element::GetAttrInteger(const CFX_ByteStringC& space, const CFX_ByteStringC& name, int& attribute) const
+bool	CXML_Element::GetAttrInteger(const CFX_ByteStringC& space, const CFX_ByteStringC& name, int& attribute) const
 {
     const CFX_WideString* pwsValue = m_AttrMap.Lookup(space, name);
     if (pwsValue) {
         attribute = pwsValue->GetInteger();
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CXML_Element::GetAttrFloat(const CFX_ByteStringC& name, FX_FLOAT& attribute) const
+bool CXML_Element::GetAttrFloat(const CFX_ByteStringC& name, FX_FLOAT& attribute) const
 {
     CFX_ByteStringC bsSpace, bsName;
     FX_XML_SplitQualifiedName(name, bsSpace, bsName);
     return GetAttrFloat(bsSpace, bsName, attribute);
 }
-FX_BOOL CXML_Element::GetAttrFloat(const CFX_ByteStringC& space, const CFX_ByteStringC& name, FX_FLOAT& attribute) const
+bool CXML_Element::GetAttrFloat(const CFX_ByteStringC& space, const CFX_ByteStringC& name, FX_FLOAT& attribute) const
 {
     const CFX_WideString* pValue = m_AttrMap.Lookup(space, name);
     if (pValue) {
         attribute = pValue->GetFloat();
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 FX_DWORD CXML_Element::CountChildren() const
 {
diff --git a/core/src/fxcrt/fxcrt_platforms.cpp b/core/src/fxcrt/fxcrt_platforms.cpp
index e7182943be..813af02ce4 100644
--- a/core/src/fxcrt/fxcrt_platforms.cpp
+++ b/core/src/fxcrt/fxcrt_platforms.cpp
@@ -40,20 +40,20 @@ CFXCRT_FileAccess_CRT::~CFXCRT_FileAccess_CRT()
 {
     Close();
 }
-FX_BOOL CFXCRT_FileAccess_CRT::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_CRT::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
 {
     if (m_hFile) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString strMode;
     FXCRT_GetFileModeString(dwMode, strMode);
     m_hFile = FXSYS_fopen(fileName.GetCStr(), strMode.c_str());
     return m_hFile != NULL;
 }
-FX_BOOL CFXCRT_FileAccess_CRT::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_CRT::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
 {
     if (m_hFile) {
-        return FALSE;
+        return false;
     }
     CFX_WideString strMode;
     FXCRT_GetFileModeString(dwMode, strMode);
@@ -128,45 +128,45 @@ size_t CFXCRT_FileAccess_CRT::WritePos(const void* pBuffer, size_t szBuffer, FX_
     FXSYS_fseek(m_hFile, pos, FXSYS_SEEK_SET);
     return FXSYS_fwrite(pBuffer, 1, szBuffer, m_hFile);
 }
-FX_BOOL CFXCRT_FileAccess_CRT::Flush()
+bool CFXCRT_FileAccess_CRT::Flush()
 {
     if (!m_hFile) {
-        return FALSE;
+        return false;
     }
     return !FXSYS_fflush(m_hFile);
 }
-FX_BOOL CFXCRT_FileAccess_CRT::Truncate(FX_FILESIZE szFile)
+bool CFXCRT_FileAccess_CRT::Truncate(FX_FILESIZE szFile)
 {
-    return FALSE;
+    return false;
 }
-FX_BOOL FX_File_Exist(const CFX_ByteStringC& fileName)
+bool FX_File_Exist(const CFX_ByteStringC& fileName)
 {
     return access(fileName.GetCStr(), F_OK) > -1;
 }
-FX_BOOL FX_File_Exist(const CFX_WideStringC& fileName)
+bool FX_File_Exist(const CFX_WideStringC& fileName)
 {
     return FX_File_Exist(FX_UTF8Encode(fileName));
 }
-FX_BOOL FX_File_Delete(const CFX_ByteStringC& fileName)
+bool FX_File_Delete(const CFX_ByteStringC& fileName)
 {
     return remove(fileName.GetCStr()) > -1;
 }
-FX_BOOL FX_File_Delete(const CFX_WideStringC& fileName)
+bool FX_File_Delete(const CFX_WideStringC& fileName)
 {
     return FX_File_Delete(FX_UTF8Encode(fileName));
 }
-FX_BOOL FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
     CFXCRT_FileAccess_CRT src, dst;
     if (!src.Open(fileNameSrc, FX_FILEMODE_ReadOnly)) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE size = src.GetSize();
     if (!size) {
-        return FALSE;
+        return false;
     }
     if (!dst.Open(fileNameDst, FX_FILEMODE_Truncate)) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE num = 0;
     uint8_t* pBuffer = FX_Alloc(uint8_t, 32768);
@@ -176,17 +176,17 @@ FX_BOOL FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC&
         }
     }
     FX_Free(pBuffer);
-    return TRUE;
+    return true;
 }
-FX_BOOL FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
     return FX_File_Copy(FX_UTF8Encode(fileNameSrc), FX_UTF8Encode(fileNameDst));
 }
-FX_BOOL FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
     return rename(fileNameSrc.GetCStr(), fileNameDst.GetCStr());
 }
-FX_BOOL FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
     return FX_File_Move(FX_UTF8Encode(fileNameSrc), FX_UTF8Encode(fileNameDst));
 }
diff --git a/core/src/fxcrt/fxcrt_platforms.h b/core/src/fxcrt/fxcrt_platforms.h
index 4fd0588c94..d95ae4f376 100644
--- a/core/src/fxcrt/fxcrt_platforms.h
+++ b/core/src/fxcrt/fxcrt_platforms.h
@@ -17,8 +17,8 @@ class CFXCRT_FileAccess_CRT : public IFXCRT_FileAccess
 public:
     CFXCRT_FileAccess_CRT();
     virtual ~CFXCRT_FileAccess_CRT();
-    virtual FX_BOOL		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
-    virtual FX_BOOL		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
     virtual void		Close();
     virtual void		Release();
     virtual FX_FILESIZE	GetSize() const;
@@ -28,8 +28,8 @@ public:
     virtual size_t		Write(const void* pBuffer, size_t szBuffer);
     virtual size_t		ReadPos(void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
     virtual size_t		WritePos(const void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
-    virtual FX_BOOL		Flush();
-    virtual FX_BOOL		Truncate(FX_FILESIZE szFile);
+    virtual bool		Flush();
+    virtual bool		Truncate(FX_FILESIZE szFile);
 protected:
     FXSYS_FILE*	m_hFile;
 };
diff --git a/core/src/fxcrt/fxcrt_posix.cpp b/core/src/fxcrt/fxcrt_posix.cpp
index 84646efd5c..eb7213e5b0 100644
--- a/core/src/fxcrt/fxcrt_posix.cpp
+++ b/core/src/fxcrt/fxcrt_posix.cpp
@@ -34,17 +34,17 @@ CFXCRT_FileAccess_Posix::~CFXCRT_FileAccess_Posix()
 {
     Close();
 }
-FX_BOOL CFXCRT_FileAccess_Posix::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_Posix::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
 {
     if (m_nFD > -1) {
-        return FALSE;
+        return false;
     }
     int32_t nFlags, nMasks;
     FXCRT_Posix_GetFileMode(dwMode, nFlags, nMasks);
     m_nFD = open(fileName.GetCStr(), nFlags, nMasks);
     return m_nFD > -1;
 }
-FX_BOOL CFXCRT_FileAccess_Posix::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_Posix::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
 {
     return Open(FX_UTF8Encode(fileName), dwMode);
 }
@@ -121,48 +121,48 @@ size_t CFXCRT_FileAccess_Posix::WritePos(const void* pBuffer, size_t szBuffer, F
     }
     return Write(pBuffer, szBuffer);
 }
-FX_BOOL CFXCRT_FileAccess_Posix::Flush()
+bool CFXCRT_FileAccess_Posix::Flush()
 {
     if (m_nFD < 0) {
-        return FALSE;
+        return false;
     }
     return fsync(m_nFD) > -1;
 }
-FX_BOOL CFXCRT_FileAccess_Posix::Truncate(FX_FILESIZE szFile)
+bool CFXCRT_FileAccess_Posix::Truncate(FX_FILESIZE szFile)
 {
     if (m_nFD < 0) {
-        return FALSE;
+        return false;
     }
     return !ftruncate(m_nFD, szFile);
 }
-FX_BOOL FX_File_Exist(const CFX_ByteStringC& fileName)
+bool FX_File_Exist(const CFX_ByteStringC& fileName)
 {
     return access(fileName.GetCStr(), F_OK) > -1;
 }
-FX_BOOL FX_File_Exist(const CFX_WideStringC& fileName)
+bool FX_File_Exist(const CFX_WideStringC& fileName)
 {
     return FX_File_Exist(FX_UTF8Encode(fileName));
 }
-FX_BOOL FX_File_Delete(const CFX_ByteStringC& fileName)
+bool FX_File_Delete(const CFX_ByteStringC& fileName)
 {
     return remove(fileName.GetCStr()) > -1;
 }
-FX_BOOL FX_File_Delete(const CFX_WideStringC& fileName)
+bool FX_File_Delete(const CFX_WideStringC& fileName)
 {
     return FX_File_Delete(FX_UTF8Encode(fileName));
 }
-FX_BOOL FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
     CFXCRT_FileAccess_Posix src, dst;
     if (!src.Open(fileNameSrc, FX_FILEMODE_ReadOnly)) {
-        return FALSE;
+        return false;
     }
     FX_FILESIZE size = src.GetSize();
     if (!size) {
-        return FALSE;
+        return false;
     }
     if (!dst.Open(fileNameDst, FX_FILEMODE_Truncate)) {
-        return FALSE;
+        return false;
     }
     size_t num = 0;
     uint8_t* pBuffer = FX_Alloc(uint8_t, 32768);
@@ -174,17 +174,17 @@ FX_BOOL FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC&
         num = src.Read(pBuffer, 32768);
     }
     FX_Free(pBuffer);
-    return TRUE;
+    return true;
 }
-FX_BOOL FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
     return FX_File_Copy(FX_UTF8Encode(fileNameSrc), FX_UTF8Encode(fileNameDst));
 }
-FX_BOOL FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
     return rename(fileNameSrc.GetCStr(), fileNameDst.GetCStr());
 }
-FX_BOOL FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
     return FX_File_Move(FX_UTF8Encode(fileNameSrc), FX_UTF8Encode(fileNameDst));
 }
diff --git a/core/src/fxcrt/fxcrt_posix.h b/core/src/fxcrt/fxcrt_posix.h
index 39df1c8507..653a150aa8 100644
--- a/core/src/fxcrt/fxcrt_posix.h
+++ b/core/src/fxcrt/fxcrt_posix.h
@@ -15,8 +15,8 @@ class CFXCRT_FileAccess_Posix : public IFXCRT_FileAccess
 public:
     CFXCRT_FileAccess_Posix();
     virtual ~CFXCRT_FileAccess_Posix();
-    virtual FX_BOOL		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
-    virtual FX_BOOL		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
     virtual void		Close();
     virtual void		Release();
     virtual FX_FILESIZE	GetSize() const;
@@ -26,8 +26,8 @@ public:
     virtual size_t		Write(const void* pBuffer, size_t szBuffer);
     virtual size_t		ReadPos(void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
     virtual size_t		WritePos(const void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
-    virtual FX_BOOL		Flush();
-    virtual FX_BOOL		Truncate(FX_FILESIZE szFile);
+    virtual bool		Flush();
+    virtual bool		Truncate(FX_FILESIZE szFile);
 protected:
     int32_t	m_nFD;
 };
diff --git a/core/src/fxcrt/fxcrt_windows.cpp b/core/src/fxcrt/fxcrt_windows.cpp
index d4e3830cf2..7effab6919 100644
--- a/core/src/fxcrt/fxcrt_windows.cpp
+++ b/core/src/fxcrt/fxcrt_windows.cpp
@@ -8,19 +8,19 @@
 #include "fxcrt_windows.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-FX_BOOL FX_File_Exist(const CFX_ByteStringC& fileName)
+bool FX_File_Exist(const CFX_ByteStringC& fileName)
 {
     FX_DWORD dwAttri = ::GetFileAttributesA(fileName.GetCStr());
     if (dwAttri == -1) {
-        return FALSE;
+        return false;
     }
     return (dwAttri & FILE_ATTRIBUTE_DIRECTORY) == 0;
 }
-FX_BOOL FX_File_Exist(const CFX_WideStringC& fileName)
+bool FX_File_Exist(const CFX_WideStringC& fileName)
 {
     FX_DWORD dwAttri = ::GetFileAttributesW((LPCWSTR)fileName.GetPtr());
     if (dwAttri == -1) {
-        return FALSE;
+        return false;
     }
     return (dwAttri & FILE_ATTRIBUTE_DIRECTORY) == 0;
 }
@@ -55,10 +55,10 @@ CFXCRT_FileAccess_Win64::~CFXCRT_FileAccess_Win64()
 {
     Close();
 }
-FX_BOOL CFXCRT_FileAccess_Win64::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_Win64::Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode)
 {
     if (m_hFile) {
-        return FALSE;
+        return false;
     }
     FX_DWORD dwAccess, dwShare, dwCreation;
     FXCRT_Windows_GetFileMode(dwMode, dwAccess, dwShare, dwCreation);
@@ -68,10 +68,10 @@ FX_BOOL CFXCRT_FileAccess_Win64::Open(const CFX_ByteStringC& fileName, FX_DWORD
     }
     return m_hFile != NULL;
 }
-FX_BOOL CFXCRT_FileAccess_Win64::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
+bool CFXCRT_FileAccess_Win64::Open(const CFX_WideStringC& fileName, FX_DWORD dwMode)
 {
     if (m_hFile) {
-        return FALSE;
+        return false;
     }
     FX_DWORD dwAccess, dwShare, dwCreation;
     FXCRT_Windows_GetFileMode(dwMode, dwAccess, dwShare, dwCreation);
@@ -174,41 +174,41 @@ size_t CFXCRT_FileAccess_Win64::WritePos(const void* pBuffer, size_t szBuffer, F
     }
     return Write(pBuffer, szBuffer);
 }
-FX_BOOL CFXCRT_FileAccess_Win64::Flush()
+bool CFXCRT_FileAccess_Win64::Flush()
 {
     if (!m_hFile) {
-        return FALSE;
+        return false;
     }
     return ::FlushFileBuffers(m_hFile);
 }
-FX_BOOL CFXCRT_FileAccess_Win64::Truncate(FX_FILESIZE szFile)
+bool CFXCRT_FileAccess_Win64::Truncate(FX_FILESIZE szFile)
 {
     if (SetPosition(szFile) == (FX_FILESIZE) - 1) {
-        return FALSE;
+        return false;
     }
     return ::SetEndOfFile(m_hFile);
 }
-FX_BOOL FX_File_Delete(const CFX_ByteStringC& fileName)
+bool FX_File_Delete(const CFX_ByteStringC& fileName)
 {
     return ::DeleteFileA(fileName.GetCStr());
 }
-FX_BOOL FX_File_Delete(const CFX_WideStringC& fileName)
+bool FX_File_Delete(const CFX_WideStringC& fileName)
 {
     return ::DeleteFileW((LPCWSTR)fileName.GetPtr());
 }
-FX_BOOL FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Copy(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
-    return ::CopyFileA(fileNameSrc.GetCStr(), fileNameDst.GetCStr(), FALSE);
+    return ::CopyFileA(fileNameSrc.GetCStr(), fileNameDst.GetCStr(), false);
 }
-FX_BOOL FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Copy(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
-    return ::CopyFileW((LPCWSTR)fileNameSrc.GetPtr(), (LPCWSTR)fileNameDst.GetPtr(), FALSE);
+    return ::CopyFileW((LPCWSTR)fileNameSrc.GetPtr(), (LPCWSTR)fileNameDst.GetPtr(), false);
 }
-FX_BOOL FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
+bool FX_File_Move(const CFX_ByteStringC& fileNameSrc, const CFX_ByteStringC& fileNameDst)
 {
     return ::MoveFileA(fileNameSrc.GetCStr(), fileNameDst.GetCStr());
 }
-FX_BOOL FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
+bool FX_File_Move(const CFX_WideStringC& fileNameSrc, const CFX_WideStringC& fileNameDst)
 {
     return ::MoveFileW((LPCWSTR)fileNameSrc.GetPtr(), (LPCWSTR)fileNameDst.GetPtr());
 }
diff --git a/core/src/fxcrt/fxcrt_windows.h b/core/src/fxcrt/fxcrt_windows.h
index 8dd2cddc82..414b863a50 100644
--- a/core/src/fxcrt/fxcrt_windows.h
+++ b/core/src/fxcrt/fxcrt_windows.h
@@ -15,8 +15,8 @@ class CFXCRT_FileAccess_Win64 : public IFXCRT_FileAccess
 public:
     CFXCRT_FileAccess_Win64();
     virtual ~CFXCRT_FileAccess_Win64();
-    virtual FX_BOOL		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
-    virtual FX_BOOL		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode);
+    virtual bool		Open(const CFX_WideStringC& fileName, FX_DWORD dwMode);
     virtual void		Close();
     virtual void		Release();
     virtual FX_FILESIZE	GetSize() const;
@@ -26,8 +26,8 @@ public:
     virtual size_t		Write(const void* pBuffer, size_t szBuffer);
     virtual size_t		ReadPos(void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
     virtual size_t		WritePos(const void* pBuffer, size_t szBuffer, FX_FILESIZE pos);
-    virtual FX_BOOL		Flush();
-    virtual FX_BOOL		Truncate(FX_FILESIZE szFile);
+    virtual bool		Flush();
+    virtual bool		Truncate(FX_FILESIZE szFile);
 protected:
     void*	m_hFile;
 };
diff --git a/core/src/fxcrt/xml_int.h b/core/src/fxcrt/xml_int.h
index 109c7a43d2..ec8bdc2850 100644
--- a/core/src/fxcrt/xml_int.h
+++ b/core/src/fxcrt/xml_int.h
@@ -23,7 +23,7 @@ public:
     {
         delete this;
     }
-    virtual FX_BOOL			IsEOF()
+    virtual bool			IsEOF()
     {
         return m_dwCurPos >= m_dwSize;
     }
@@ -35,16 +35,16 @@ public:
     {
         return 0;
     }
-    virtual FX_BOOL			ReadNextBlock(FX_BOOL bRestart = FALSE)
+    virtual bool			ReadNextBlock(bool bRestart = false)
     {
         if (bRestart) {
             m_dwCurPos = 0;
         }
         if (m_dwCurPos < m_dwSize) {
             m_dwCurPos = m_dwSize;
-            return TRUE;
+            return true;
         }
-        return FALSE;
+        return false;
     }
     virtual const uint8_t*		GetBlockBuffer()
     {
@@ -85,7 +85,7 @@ public:
     {
         delete this;
     }
-    virtual FX_BOOL			IsEOF()
+    virtual bool			IsEOF()
     {
         return m_nStart + (FX_FILESIZE)m_dwSize >= m_pFileRead->GetSize();
     }
@@ -97,7 +97,7 @@ public:
     {
         return 0;
     }
-    virtual FX_BOOL			ReadNextBlock(FX_BOOL bRestart = FALSE)
+    virtual bool			ReadNextBlock(bool bRestart = false)
     {
         if (bRestart) {
             m_nStart = 0;
@@ -105,7 +105,7 @@ public:
         FX_FILESIZE nLength = m_pFileRead->GetSize();
         m_nStart += (FX_FILESIZE)m_dwSize;
         if (m_nStart >= nLength) {
-            return FALSE;
+            return false;
         }
         m_dwSize = (size_t)FX_MIN(FX_XMLDATASTREAM_BufferSize, nLength - m_nStart);
         if (!m_pBuffer) {
@@ -136,28 +136,28 @@ class CXML_Parser
 public:
     ~CXML_Parser();
     IFX_BufferRead*	m_pDataAcc;
-    FX_BOOL			m_bOwnedStream;
+    bool			m_bOwnedStream;
     FX_FILESIZE		m_nOffset;
-    FX_BOOL			m_bSaveSpaceChars;
+    bool			m_bSaveSpaceChars;
     const uint8_t*		m_pBuffer;
     size_t			m_dwBufferSize;
     FX_FILESIZE		m_nBufferOffset;
     size_t			m_dwIndex;
-    FX_BOOL			Init(uint8_t* pBuffer, size_t size);
-    FX_BOOL			Init(IFX_FileRead *pFileRead);
-    FX_BOOL			Init(IFX_BufferRead *pBuffer);
-    FX_BOOL			Init(FX_BOOL bOwndedStream);
-    FX_BOOL			ReadNextBlock();
-    FX_BOOL			IsEOF();
-    FX_BOOL			HaveAvailData();
+    bool			Init(uint8_t* pBuffer, size_t size);
+    bool			Init(IFX_FileRead *pFileRead);
+    bool			Init(IFX_BufferRead *pBuffer);
+    bool			Init(bool bOwndedStream);
+    bool			ReadNextBlock();
+    bool			IsEOF();
+    bool			HaveAvailData();
     void			SkipWhiteSpaces();
     void			GetName(CFX_ByteString& space, CFX_ByteString& name);
     void			GetAttrValue(CFX_WideString &value);
     FX_DWORD		GetCharRef();
-    void			GetTagName(CFX_ByteString &space, CFX_ByteString &name, FX_BOOL &bEndTag, FX_BOOL bStartTag = FALSE);
+    void			GetTagName(CFX_ByteString &space, CFX_ByteString &name, bool &bEndTag, bool bStartTag = false);
     void			SkipLiterals(const CFX_ByteStringC& str);
-    CXML_Element*	ParseElement(CXML_Element* pParent, FX_BOOL bStartTag = FALSE);
-    void			InsertContentSegment(FX_BOOL bCDATA, const CFX_WideStringC& content, CXML_Element* pElement);
+    CXML_Element*	ParseElement(CXML_Element* pParent, bool bStartTag = false);
+    void			InsertContentSegment(bool bCDATA, const CFX_WideStringC& content, CXML_Element* pElement);
     void			InsertCDATASegment(CFX_UTF8Decoder& decoder, CXML_Element* pElement);
 };
 void FX_XML_SplitQualifiedName(const CFX_ByteStringC& bsFullName, CFX_ByteStringC &bsSpace, CFX_ByteStringC &bsName);
diff --git a/core/src/fxge/agg/include/fx_agg_driver.h b/core/src/fxge/agg/include/fx_agg_driver.h
index 29b56c77e4..c8d620122e 100644
--- a/core/src/fxge/agg/include/fx_agg_driver.h
+++ b/core/src/fxge/agg/include/fx_agg_driver.h
@@ -22,7 +22,7 @@ public:
 class CFX_AggDeviceDriver : public IFX_RenderDeviceDriver
 {
 public:
-    CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout);
+    CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout);
     virtual ~CFX_AggDeviceDriver();
     void				InitPlatform();
     void				DestroyPlatform();
@@ -32,22 +32,22 @@ public:
 
 
     virtual void		SaveState();
-    virtual void		RestoreState(FX_BOOL bKeepSaved);
+    virtual void		RestoreState(bool bKeepSaved);
 
 
-    virtual FX_BOOL		SetClip_PathFill(const CFX_PathData* pPathData,
+    virtual bool		SetClip_PathFill(const CFX_PathData* pPathData,
                                          const CFX_AffineMatrix* pObject2Device,
                                          int fill_mode
                                      );
 
 
-    virtual FX_BOOL		SetClip_PathStroke(const CFX_PathData* pPathData,
+    virtual bool		SetClip_PathStroke(const CFX_PathData* pPathData,
                                            const CFX_AffineMatrix* pObject2Device,
                                            const CFX_GraphStateData* pGraphState
                                        );
 
 
-    virtual FX_BOOL		DrawPath(const CFX_PathData* pPathData,
+    virtual bool		DrawPath(const CFX_PathData* pPathData,
                                  const CFX_AffineMatrix* pObject2Device,
                                  const CFX_GraphStateData* pGraphState,
                                  FX_DWORD fill_color,
@@ -58,44 +58,44 @@ public:
                                  int blend_type
                              );
 
-    virtual FX_BOOL		SetPixel(int x, int y, FX_DWORD color,
+    virtual bool		SetPixel(int x, int y, FX_DWORD color,
                                  int alpha_flag, void* pIccTransform);
 
-    virtual FX_BOOL		FillRect(const FX_RECT* pRect,
+    virtual bool		FillRect(const FX_RECT* pRect,
                                  FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type);
 
 
-    virtual FX_BOOL		DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+    virtual bool		DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
                                          int alpha_flag, void* pIccTransform, int blend_type)
     {
-        return FALSE;
+        return false;
     }
 
-    virtual FX_BOOL		GetClipBox(FX_RECT* pRect);
+    virtual bool		GetClipBox(FX_RECT* pRect);
 
 
-    virtual FX_BOOL		GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, FX_BOOL bDEdge = FALSE);
+    virtual bool		GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, bool bDEdge = false);
     virtual CFX_DIBitmap*   GetBackDrop()
     {
         return m_pOriDevice;
     }
 
-    virtual FX_BOOL		SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+    virtual bool		SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                   int alpha_flag, void* pIccTransform);
-    virtual FX_BOOL		StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+    virtual bool		StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                       int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                       int alpha_flag, void* pIccTransform, int blend_type);
 
-    virtual FX_BOOL		StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+    virtual bool		StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                     const CFX_AffineMatrix* pMatrix, FX_DWORD flags, void*& handle,
                                     int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL		ContinueDIBits(void* handle, IFX_Pause* pPause);
+    virtual bool		ContinueDIBits(void* handle, IFX_Pause* pPause);
     virtual void		CancelDIBits(void* handle);
 
-    virtual FX_BOOL     DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+    virtual bool     DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
                                        CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
                                        int alpha_flag, void* pIccTransform);
-    virtual FX_BOOL		RenderRasterizer(FX_NAMESPACE_DECLARE(agg, rasterizer_scanline_aa)& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
+    virtual bool		RenderRasterizer(FX_NAMESPACE_DECLARE(agg, rasterizer_scanline_aa)& rasterizer, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
                                          int alpha_flag, void* pIccTransform);
 
     void				SetClipMask(FX_NAMESPACE_DECLARE(agg, rasterizer_scanline_aa)& rasterizer);
@@ -117,9 +117,9 @@ public:
     void*				m_pDwRenderTartget;
     int					m_FillFlags;
     int					m_DitherBits;
-    FX_BOOL				m_bRgbByteOrder;
+    bool				m_bRgbByteOrder;
     CFX_DIBitmap*       m_pOriDevice;
-    FX_BOOL             m_bGroupKnockout;
+    bool             m_bGroupKnockout;
 };
 
 #endif  // FX_AGG_DRIVER_H_
diff --git a/core/src/fxge/agg/src/fx_agg_driver.cpp b/core/src/fxge/agg/src/fx_agg_driver.cpp
index 118db7bf1f..2f96ef7379 100644
--- a/core/src/fxge/agg/src/fx_agg_driver.cpp
+++ b/core/src/fxge/agg/src/fx_agg_driver.cpp
@@ -119,7 +119,7 @@ private:
 static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer, agg::path_storage& path_data,
                             const CFX_AffineMatrix* pObject2Device,
                             const CFX_GraphStateData* pGraphState, FX_FLOAT scale = 1.0f,
-                            FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE)
+                            bool bStrokeAdjust = false, bool bTextMode = false)
 {
     agg::line_cap_e cap;
     switch (pGraphState->m_LineCap) {
@@ -185,11 +185,11 @@ static void RasterizeStroke(agg::rasterizer_scanline_aa& rasterizer, agg::path_s
         rasterizer.add_path_transformed(stroke, pObject2Device);
     }
 }
-IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(CFX_DIBitmap* pBitmap, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(CFX_DIBitmap* pBitmap, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
     return new CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice, bGroupKnockout);
 }
-CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
     m_pBitmap = pBitmap;
     m_DitherBits = dither_bits;
@@ -217,11 +217,11 @@ void CFX_AggDeviceDriver::InitPlatform()
 void CFX_AggDeviceDriver::DestroyPlatform()
 {
 }
-FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+bool CFX_AggDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
         CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
         int alpha_flag, void* pIccTransform)
 {
-    return FALSE;
+    return false;
 }
 #endif
 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id)
@@ -267,7 +267,7 @@ void CFX_AggDeviceDriver::SaveState()
     }
     m_StateStack.Add(pClip);
 }
-void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved)
+void CFX_AggDeviceDriver::RestoreState(bool bKeepSaved)
 {
     if (m_StateStack.GetSize() == 0) {
         delete m_pClipRgn;
@@ -307,7 +307,7 @@ void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer)
     agg::render_scanlines(rasterizer, scanline, final_render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
     m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
 }
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
+bool CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pObject2Device,
         int fill_mode
                                              )
@@ -322,7 +322,7 @@ FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
             rectf.Intersect(CFX_FloatRect(0, 0, (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
             FX_RECT rect = rectf.GetOutterRect();
             m_pClipRgn->IntersectRect(rect);
-            return TRUE;
+            return true;
         }
     }
     CAgg_PathData path_data;
@@ -333,9 +333,9 @@ FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
     rasterizer.add_path(path_data.m_PathData);
     rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd);
     SetClipMask(rasterizer);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
+bool CFX_AggDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pObject2Device,
         const CFX_GraphStateData* pGraphState
                                                )
@@ -350,7 +350,7 @@ FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
     RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device, pGraphState);
     rasterizer.filling_rule(agg::fill_non_zero);
     SetClipMask(rasterizer);
-    return TRUE;
+    return true;
 }
 class CFX_Renderer 
 {
@@ -361,8 +361,8 @@ private:
                 m_Blue,
                 m_Gray;
     FX_DWORD	m_Color;
-    FX_BOOL		m_bFullCover;
-    FX_BOOL     m_bRgbByteOrder;
+    bool		m_bFullCover;
+    bool     m_bRgbByteOrder;
     CFX_DIBitmap* m_pOriDevice;
     FX_RECT		m_ClipBox;
     const CFX_DIBitmap*	m_pClipMask;
@@ -371,7 +371,7 @@ private:
     void (CFX_Renderer::*composite_span)(uint8_t*, int, int, int, uint8_t*, int, int, uint8_t*, uint8_t*);
 public:
     void prepare(unsigned) {}
-    void CompositeSpan(uint8_t* dest_scan, uint8_t* ori_scan, int Bpp, FX_BOOL bDestAlpha,
+    void CompositeSpan(uint8_t* dest_scan, uint8_t* ori_scan, int Bpp, bool bDestAlpha,
                        int span_left, int span_len, uint8_t* cover_scan,
                        int clip_left, int clip_right, uint8_t* clip_scan)
     {
@@ -955,7 +955,7 @@ public:
             ori_scan = m_pOriDevice->GetBuffer() + m_pOriDevice->GetPitch() * y;
         }
         int Bpp = m_pDevice->GetBPP() / 8;
-        FX_BOOL bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
+        bool bDestAlpha = m_pDevice->HasAlpha() || m_pDevice->IsAlphaMask();
         unsigned num_spans = sl.num_spans();
         typename Scanline::const_iterator span = sl.begin();
         while (1) {
@@ -988,7 +988,7 @@ public:
         }
     }
 
-    FX_BOOL Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder,
+    bool Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, bool bFullCover, bool bRgbByteOrder,
                  int alpha_flag = 0, void* pIccTransform = NULL)
     {
         m_pDevice = pDevice;
@@ -1008,8 +1008,8 @@ public:
             m_pClipMask = m_pClipRgn->GetMask();
         }
         m_bFullCover = bFullCover;
-        FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
-        FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
+        bool bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
+        bool bDeviceCMYK = pDevice->IsCmykImage();
         m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
         ICodec_IccModule* pIccModule = NULL;
         if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
@@ -1039,7 +1039,7 @@ public:
                     }
                 }
             }
-            return TRUE;
+            return true;
         }
         if (bDeviceCMYK) {
             ASSERT(!m_bRgbByteOrder);
@@ -1051,7 +1051,7 @@ public:
                 }
             } else {
                 if (!pIccTransform) {
-                    return FALSE;
+                    return false;
                 }
                 color = FXARGB_TODIB(color);
                 pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1);
@@ -1100,22 +1100,22 @@ public:
         if (m_pDevice->GetBPP() == 1) {
             composite_span = &CFX_Renderer::CompositeSpan1bpp;
         }
-        return TRUE;
+        return true;
     }
 };
-FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(agg::rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
+bool CFX_AggDeviceDriver::RenderRasterizer(agg::rasterizer_scanline_aa& rasterizer, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
         int alpha_flag, void* pIccTransform)
 {
     CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
     CFX_Renderer render;
     if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover, m_bRgbByteOrder, alpha_flag, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     agg::scanline_u8 scanline;
     agg::render_scanlines(rasterizer, scanline, render, (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
-    return TRUE;
+    return true;
 }
-FX_BOOL	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
+bool	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                       const CFX_AffineMatrix* pObject2Device,
                                       const CFX_GraphStateData* pGraphState,
                                       FX_DWORD fill_color,
@@ -1127,10 +1127,10 @@ FX_BOOL	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                      )
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     if (GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     m_FillFlags = fill_mode;
     if ((fill_mode & 3) && fill_color) {
@@ -1140,8 +1140,8 @@ FX_BOOL	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
         rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
         rasterizer.add_path(path_data.m_PathData);
         rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING ? agg::fill_non_zero : agg::fill_even_odd);
-        if (!RenderRasterizer(rasterizer, fill_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform)) {
-            return FALSE;
+        if (!RenderRasterizer(rasterizer, fill_color, fill_mode & FXFILL_FULLCOVER, false, alpha_flag, pIccTransform)) {
+            return false;
         }
     }
     int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color);
@@ -1151,12 +1151,12 @@ FX_BOOL	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
             path_data.BuildPath(pPathData, pObject2Device);
             agg::rasterizer_scanline_aa rasterizer;
             rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
-            RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1, FALSE, fill_mode & FX_STROKE_TEXT_MODE);
+            RasterizeStroke(rasterizer, path_data.m_PathData, NULL, pGraphState, 1, false, fill_mode & FX_STROKE_TEXT_MODE);
             int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
             if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) {
-                return FALSE;
+                return false;
             }
-            return TRUE;
+            return true;
         }
         CFX_AffineMatrix matrix1, matrix2;
         if (pObject2Device) {
@@ -1174,13 +1174,13 @@ FX_BOOL	CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
         path_data.BuildPath(pPathData, &matrix1);
         agg::rasterizer_scanline_aa rasterizer;
         rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)), (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
-        RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, fill_mode & FX_STROKE_TEXT_MODE);
+        RasterizeStroke(rasterizer, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, false, fill_mode & FX_STROKE_TEXT_MODE);
         int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
         if (!RenderRasterizer(rasterizer, stroke_color, fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout, fill_flag, pIccTransform)) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb)
 {
@@ -1208,7 +1208,7 @@ void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap, int left, int top, int wid
     width = rect.Width();
     int src_r = FXARGB_R(argb), src_g = FXARGB_G(argb), src_b = FXARGB_B(argb);
     int Bpp = pBitmap->GetBPP() / 8;
-    FX_BOOL bAlpha = pBitmap->HasAlpha();
+    bool bAlpha = pBitmap->HasAlpha();
     int dib_argb = FXARGB_TOBGRORDERDIB(argb);
     uint8_t* pBuffer = pBitmap->GetBuffer();
     if (src_alpha == 255) {
@@ -1317,7 +1317,7 @@ void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap, int dest_left, int dest_t
                 }
             }
         } else {
-            ASSERT(FALSE);
+            ASSERT(false);
         }
     } else if (dest_format == FXDIB_Argb || dest_format == FXDIB_Rgb32) {
         if (src_format == FXDIB_Rgb) {
@@ -1351,7 +1351,7 @@ void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap, int dest_left, int dest_t
             }
         }
     } else {
-        ASSERT(FALSE);
+        ASSERT(false);
     }
 }
 FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha)
@@ -1361,9 +1361,9 @@ FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha)
                        r, g, b);
     return ArgbEncode(alpha, r, g, b);
 }
-FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
+bool _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
-    FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
+    bool bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
     int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ -1376,7 +1376,7 @@ FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int al
     } else {
         if (pDevice->IsCmykImage()) {
             if (!bObjCMYK) {
-                return FALSE;
+                return false;
             }
         } else {
             if (bObjCMYK) {
@@ -1388,12 +1388,12 @@ FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice, int x, int y, FX_DWORD color, int al
     if (pDevice->m_pAlphaMask) {
         pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
+bool CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         pIccTransform = NULL;
@@ -1413,12 +1413,12 @@ FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_fl
             }
         } else if (m_pClipRgn->GetType() == CFX_ClipRgn::MaskF) {
             const CFX_DIBitmap* pMask = m_pClipRgn->GetMask();
-            FX_BOOL bCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
+            bool bCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
             int new_alpha = bCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
             new_alpha = new_alpha * pMask->GetScanline(y)[x] / 255;
             if (m_bRgbByteOrder) {
                 RgbByteOrderSetPixel(m_pBitmap, x, y, (color & 0xffffff) | (new_alpha << 24));
-                return TRUE;
+                return true;
             }
             if (bCMYK) {
                 FXSETFLAG_ALPHA_FILL(alpha_flag, new_alpha);
@@ -1428,15 +1428,15 @@ FX_BOOL CFX_AggDeviceDriver::SetPixel(int x, int y, FX_DWORD color, int alpha_fl
             return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
+bool CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     FX_RECT clip_rect;
     GetClipBox(&clip_rect);
@@ -1445,7 +1445,7 @@ FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
         draw_rect.Intersect(*pRect);
     }
     if (draw_rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     if (m_pClipRgn == NULL || m_pClipRgn->GetType() == CFX_ClipRgn::RectI) {
         if (m_bRgbByteOrder) {
@@ -1453,27 +1453,27 @@ FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
         } else {
             m_pBitmap->CompositeRect(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), fill_color, alpha_flag, pIccTransform);
         }
-        return TRUE;
+        return true;
     }
     m_pBitmap->CompositeMask(draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(), (const CFX_DIBitmap*)m_pClipRgn->GetMask(),
                              fill_color, draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top, FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect)
+bool CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect)
 {
     if (m_pClipRgn == NULL) {
         pRect->left = pRect->top = 0;
         pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
         pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
-        return TRUE;
+        return true;
     }
     *pRect = m_pClipRgn->GetBox();
-    return TRUE;
+    return true;
 }
-FX_BOOL	CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
+bool	CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, bool bDEdge)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     if (bDEdge) {
         if (m_bRgbByteOrder) {
@@ -1481,23 +1481,23 @@ FX_BOOL	CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top,
         } else {
             return pBitmap->TransferBitmap(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight(), m_pBitmap, left, top, pIccTransform);
         }
-        return TRUE;
+        return true;
     }
     FX_RECT rect(left, top, left + pBitmap->GetWidth(), top + pBitmap->GetHeight());
     CFX_DIBitmap *pBack = NULL;
     if (m_pOriDevice) {
         pBack = m_pOriDevice->Clone(&rect);
         if (!pBack) {
-            return TRUE;
+            return true;
         }
         pBack->CompositeBitmap(0, 0, pBack->GetWidth(), pBack->GetHeight(), m_pBitmap, 0, 0);
     } else {
         pBack = m_pBitmap->Clone(&rect);
     }
     if (!pBack) {
-        return TRUE;
+        return true;
     }
-    FX_BOOL bRet = TRUE;
+    bool bRet = true;
     left = left >= 0 ? 0 : left;
     top = top >= 0 ? 0 : top;
     if (m_bRgbByteOrder) {
@@ -1508,11 +1508,11 @@ FX_BOOL	CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top,
     delete pBack;
     return bRet;
 }
-FX_BOOL	CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool	CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                        int alpha_flag, void* pIccTransform)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     if (pBitmap->IsAlphaMask())
         return m_pBitmap->CompositeMask(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
@@ -1520,12 +1520,12 @@ FX_BOOL	CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD ar
     return m_pBitmap->CompositeBitmap(left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap,
                                       pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform);
 }
-FX_BOOL	CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
+bool	CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     if (dest_width == pSource->GetWidth() && dest_height == pSource->GetHeight()) {
         FX_RECT rect(0, 0, dest_width, dest_height);
@@ -1536,30 +1536,30 @@ FX_BOOL	CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWOR
     FX_RECT dest_clip = dest_rect;
     dest_clip.Intersect(*pClipRect);
     CFX_BitmapComposer composer;
-    composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, blend_type);
+    composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, false, false, false, m_bRgbByteOrder, alpha_flag, pIccTransform, blend_type);
     dest_clip.Offset(-dest_rect.left, -dest_rect.top);
     CFX_ImageStretcher stretcher;
     if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip, flags)) {
         stretcher.Continue(NULL);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL	CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
+bool	CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
         const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
     pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix, render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform);
     handle = pRenderer;
-    return TRUE;
+    return true;
 }
-FX_BOOL	CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
+bool	CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
 {
     if (m_pBitmap->GetBuffer() == NULL) {
-        return TRUE;
+        return true;
     }
     return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
 }
@@ -1572,30 +1572,30 @@ void CFX_AggDeviceDriver::CancelDIBits(void* pHandle)
 }
 CFX_FxgeDevice::CFX_FxgeDevice()
 {
-    m_bOwnedBitmap = FALSE;
+    m_bOwnedBitmap = false;
 }
-FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+bool CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
     if (pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     SetBitmap(pBitmap);
     IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_FxgeDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
+bool CFX_FxgeDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
 {
-    m_bOwnedBitmap = TRUE;
+    m_bOwnedBitmap = true;
     CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
     if (!pBitmap->Create(width, height, format)) {
         delete pBitmap;
-        return FALSE;
+        return false;
     }
     SetBitmap(pBitmap);
-    IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
+    IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, false, pOriDevice, false);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
 CFX_FxgeDevice::~CFX_FxgeDevice()
 {
diff --git a/core/src/fxge/android/fpf_skiafont.cpp b/core/src/fxge/android/fpf_skiafont.cpp
index 2dad01057a..f5ac6c0ce6 100644
--- a/core/src/fxge/android/fpf_skiafont.cpp
+++ b/core/src/fxge/android/fpf_skiafont.cpp
@@ -87,23 +87,23 @@ int32_t CFPF_SkiaFont::GetDescent() const
     }
     return FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_Descender(m_Face));
 }
-FX_BOOL CFPF_SkiaFont::GetGlyphBBox(int32_t iGlyphIndex, FX_RECT &rtBBox)
+bool CFPF_SkiaFont::GetGlyphBBox(int32_t iGlyphIndex, FX_RECT &rtBBox)
 {
     if (!m_Face) {
-        return FALSE;
+        return false;
     }
     if (FXFT_Is_Face_Tricky(m_Face)) {
         if (FXFT_Set_Char_Size(m_Face, 0, 1000 * 64, 72, 72)) {
-            return FALSE;
+            return false;
         }
         if (FXFT_Load_Glyph(m_Face, iGlyphIndex, FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH)) {
             FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
-            return FALSE;
+            return false;
         }
         FXFT_Glyph glyph;
         if (FXFT_Get_Glyph(m_Face->glyph, &glyph)) {
             FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
-            return FALSE;
+            return false;
         }
         FXFT_BBox cbox;
         FXFT_Glyph_Get_CBox(glyph, FXFT_GLYPH_BBOX_PIXELS, &cbox);
@@ -119,24 +119,24 @@ FX_BOOL CFPF_SkiaFont::GetGlyphBBox(int32_t iGlyphIndex, FX_RECT &rtBBox)
         return FXFT_Set_Pixel_Sizes(m_Face, 0, 64) == 0;
     }
     if (FXFT_Load_Glyph(m_Face, iGlyphIndex, FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH)) {
-        return FALSE;
+        return false;
     }
     rtBBox.left = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Glyph_HoriBearingX(m_Face));
     rtBBox.bottom = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Glyph_HoriBearingY(m_Face));
     rtBBox.right = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Glyph_HoriBearingX(m_Face) + FXFT_Get_Glyph_Width(m_Face));
     rtBBox.top = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Glyph_HoriBearingY(m_Face) - FXFT_Get_Glyph_Height(m_Face));
-    return TRUE;
+    return true;
 }
-FX_BOOL CFPF_SkiaFont::GetBBox(FX_RECT &rtBBox)
+bool CFPF_SkiaFont::GetBBox(FX_RECT &rtBBox)
 {
     if (!m_Face) {
-        return FALSE;
+        return false;
     }
     rtBBox.left = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_xMin(m_Face));
     rtBBox.top = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_yMin(m_Face));
     rtBBox.right = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_xMax(m_Face));
     rtBBox.bottom = FPF_EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_yMax(m_Face));
-    return TRUE;
+    return true;
 }
 int32_t CFPF_SkiaFont::GetHeight() const
 {
@@ -167,10 +167,10 @@ FX_DWORD CFPF_SkiaFont::GetFontData(FX_DWORD dwTable, uint8_t* pBuffer, FX_DWORD
     }
     return pdfium::base::checked_cast<FX_DWORD>(ulSize);
 }
-FX_BOOL CFPF_SkiaFont::InitFont(CFPF_SkiaFontMgr *pFontMgr, CFPF_SkiaFontDescriptor *pFontDes, const CFX_ByteStringC& bsFamily, FX_DWORD dwStyle, uint8_t uCharset)
+bool CFPF_SkiaFont::InitFont(CFPF_SkiaFontMgr *pFontMgr, CFPF_SkiaFontDescriptor *pFontDes, const CFX_ByteStringC& bsFamily, FX_DWORD dwStyle, uint8_t uCharset)
 {
     if (!pFontMgr || !pFontDes) {
-        return FALSE;
+        return false;
     }
     switch (pFontDes->GetType()) {
         case FPF_SKIAFONTTYPE_Path: {
@@ -189,16 +189,16 @@ FX_BOOL CFPF_SkiaFont::InitFont(CFPF_SkiaFontMgr *pFontMgr, CFPF_SkiaFontDescrip
             }
             break;
         default:
-            return FALSE;
+            return false;
     }
     if (!m_Face) {
-        return FALSE;
+        return false;
     }
     m_dwStyle = dwStyle;
     m_uCharset = uCharset;
     m_pFontMgr = pFontMgr;
     m_pFontDes = pFontDes;
     m_dwRefCount = 1;
-    return TRUE;
+    return true;
 }
 #endif
diff --git a/core/src/fxge/android/fpf_skiafont.h b/core/src/fxge/android/fpf_skiafont.h
index 49819d4c11..90cf5cb29c 100644
--- a/core/src/fxge/android/fpf_skiafont.h
+++ b/core/src/fxge/android/fpf_skiafont.h
@@ -39,13 +39,13 @@ public:
     virtual int32_t		GetAscent() const;
     virtual int32_t		GetDescent() const;
 
-    virtual FX_BOOL			GetGlyphBBox(int32_t iGlyphIndex, FX_RECT &rtBBox);
-    virtual FX_BOOL			GetBBox(FX_RECT &rtBBox);
+    virtual bool			GetGlyphBBox(int32_t iGlyphIndex, FX_RECT &rtBBox);
+    virtual bool			GetBBox(FX_RECT &rtBBox);
 
     virtual int32_t		GetHeight() const;
     virtual int32_t		GetItalicAngle() const;
     virtual FX_DWORD		GetFontData(FX_DWORD dwTable, uint8_t* pBuffer, FX_DWORD dwSize);
-    FX_BOOL					InitFont(CFPF_SkiaFontMgr *pFontMgr, CFPF_SkiaFontDescriptor *pFontDes, const CFX_ByteStringC& bsFamily, FX_DWORD dwStyle, uint8_t uCharset);
+    bool					InitFont(CFPF_SkiaFontMgr *pFontMgr, CFPF_SkiaFontDescriptor *pFontDes, const CFX_ByteStringC& bsFamily, FX_DWORD dwStyle, uint8_t uCharset);
 protected:
     CFPF_SkiaFontMgr		*m_pFontMgr;
     CFPF_SkiaFontDescriptor	*m_pFontDes;
diff --git a/core/src/fxge/android/fpf_skiafontmgr.cpp b/core/src/fxge/android/fpf_skiafontmgr.cpp
index 86bb052435..8c835392fc 100644
--- a/core/src/fxge/android/fpf_skiafontmgr.cpp
+++ b/core/src/fxge/android/fpf_skiafontmgr.cpp
@@ -103,7 +103,7 @@ FX_DWORD FPF_SkiaGetSansFont(FX_DWORD dwHash)
     }
     return 0;
 }
-static uint32_t FPF_GetHashCode_StringA(const FX_CHAR* pStr, int32_t iLength, FX_BOOL bIgnoreCase = FALSE)
+static uint32_t FPF_GetHashCode_StringA(const FX_CHAR* pStr, int32_t iLength, bool bIgnoreCase = false)
 {
     if (!pStr) {
         return 0;
@@ -208,27 +208,27 @@ static FX_DWORD	FPF_SKIAGetFamilyHash(const CFX_ByteStringC& bsFamily, FX_DWORD
         bsFont += "Serif";
     }
     bsFont += uCharset;
-    return FPF_GetHashCode_StringA(bsFont.c_str(), bsFont.GetLength(), TRUE);
+    return FPF_GetHashCode_StringA(bsFont.c_str(), bsFont.GetLength(), true);
 }
-static FX_BOOL FPF_SkiaIsCJK(uint8_t uCharset)
+static bool FPF_SkiaIsCJK(uint8_t uCharset)
 {
     return (uCharset == FXFONT_GB2312_CHARSET) || (uCharset == FXFONT_CHINESEBIG5_CHARSET)
            || (uCharset == FXFONT_HANGEUL_CHARSET) || (uCharset == FXFONT_SHIFTJIS_CHARSET);
 }
-static FX_BOOL FPF_SkiaMaybeSymbol(const CFX_ByteStringC& bsFacename)
+static bool FPF_SkiaMaybeSymbol(const CFX_ByteStringC& bsFacename)
 {
     CFX_ByteString bsName = bsFacename;
     bsName.MakeLower();
     return bsName.Find("symbol") > -1;
 }
-static FX_BOOL FPF_SkiaMaybeArabic(const CFX_ByteStringC& bsFacename)
+static bool FPF_SkiaMaybeArabic(const CFX_ByteStringC& bsFacename)
 {
     CFX_ByteString bsName = bsFacename;
     bsName.MakeLower();
     return bsName.Find("arabic") > -1;
 }
 CFPF_SkiaFontMgr::CFPF_SkiaFontMgr()
-    : m_bLoaded(FALSE), m_FTLibrary(NULL)
+    : m_bLoaded(false), m_FTLibrary(NULL)
 {
 }
 CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr()
@@ -252,7 +252,7 @@ CFPF_SkiaFontMgr::~CFPF_SkiaFontMgr()
         FXFT_Done_FreeType(m_FTLibrary);
     }
 }
-FX_BOOL CFPF_SkiaFontMgr::InitFTLibrary()
+bool CFPF_SkiaFontMgr::InitFTLibrary()
 {
     if (m_FTLibrary == NULL) {
         FXFT_Init_FreeType(&m_FTLibrary);
@@ -266,7 +266,7 @@ void CFPF_SkiaFontMgr::LoadSystemFonts()
     }
     ScanPath(FX_BSTRC("/system/fonts"));
     OutputSystemFonts();
-    m_bLoaded = TRUE;
+    m_bLoaded = true;
 }
 void CFPF_SkiaFontMgr::LoadPrivateFont(IFX_FileRead* pFontFile)
 {
@@ -289,7 +289,7 @@ IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname, uin
     FX_DWORD dwFaceName = FPF_SKIANormalizeFontName(bsFamilyname);
     FX_DWORD dwSubst = FPF_SkiaGetSubstFont(dwFaceName);
     FX_DWORD dwSubstSans = FPF_SkiaGetSansFont(dwFaceName);
-    FX_BOOL bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
+    bool bMaybeSymbol = FPF_SkiaMaybeSymbol(bsFamilyname);
     if (uCharset != FXFONT_ARABIC_CHARSET && FPF_SkiaMaybeArabic(bsFamilyname)) {
         uCharset = FXFONT_ARABIC_CHARSET;
     } else if (uCharset == FXFONT_ANSI_CHARSET && (dwMatch & FPF_MATCHFONT_REPLACEANSI)) {
@@ -309,7 +309,7 @@ IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname, uin
         if (dwFaceName == dwSysFontName) {
             nFind += FPF_SKIAMATCHWEIGHT_NAME1;
         }
-        FX_BOOL bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
+        bool bMatchedName = (nFind == FPF_SKIAMATCHWEIGHT_NAME1);
         if ((dwStyle & FXFONT_BOLD) == (pFontDes->m_dwStyle & FXFONT_BOLD)) {
             nFind += FPF_SKIAMATCHWEIGHT_1;
         }
@@ -327,7 +327,7 @@ IFPF_Font* CFPF_SkiaFontMgr::CreateFont(const CFX_ByteStringC& bsFamilyname, uin
         }
         if (dwSubst == dwSysFontName || dwSubstSans == dwSysFontName) {
             nFind += FPF_SKIAMATCHWEIGHT_NAME2;
-            bMatchedName = TRUE;
+            bMatchedName = true;
         }
         if (uCharset == FXFONT_DEFAULT_CHARSET || bMaybeSymbol) {
             if (nFind > nMax && bMatchedName) {
@@ -399,7 +399,7 @@ FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const CFX_ByteStringC& bsFile, int32_t i
     args.pathname = (FT_String*)bsFile.GetCStr();
     FXFT_Face face;
     if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
-        return FALSE;
+        return false;
     }
     FXFT_Set_Pixel_Sizes(face, 0, 64);
     return face;
@@ -418,7 +418,7 @@ FXFT_Face CFPF_SkiaFontMgr::GetFontFace(const uint8_t* pBuffer, size_t szBuffer,
     args.memory_size = szBuffer;
     FXFT_Face face;
     if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
-        return FALSE;
+        return false;
     }
     FXFT_Set_Pixel_Sizes(face, 0, 64);
     return face;
@@ -430,7 +430,7 @@ void CFPF_SkiaFontMgr::ScanPath(const CFX_ByteStringC& path)
         return;
     }
     CFX_ByteString filename;
-    FX_BOOL	bFolder = FALSE;
+    bool	bFolder = false;
     while (FX_GetNextFile(handle, filename, bFolder)) {
         if (bFolder) {
             if (filename == FX_BSTRC(".") || filename == FX_BSTRC("..")) {
diff --git a/core/src/fxge/android/fpf_skiafontmgr.h b/core/src/fxge/android/fpf_skiafontmgr.h
index 8c721ff68a..b4ebe9454a 100644
--- a/core/src/fxge/android/fpf_skiafontmgr.h
+++ b/core/src/fxge/android/fpf_skiafontmgr.h
@@ -94,7 +94,7 @@ class CFPF_SkiaFontMgr : public IFPF_FontMgr
 public:
     CFPF_SkiaFontMgr();
     virtual ~CFPF_SkiaFontMgr();
-    FX_BOOL					InitFTLibrary();
+    bool					InitFTLibrary();
     virtual void			LoadSystemFonts();
     virtual void			LoadPrivateFont(IFX_FileRead* pFontFile);
     virtual void			LoadPrivateFont(const CFX_ByteStringC& bsFileName);
@@ -109,7 +109,7 @@ protected:
     void				ScanFile(const CFX_ByteStringC& file);
     void				ReportFace(FXFT_Face face, CFPF_SkiaFontDescriptor *pFontDesc);
     void				OutputSystemFonts();
-    FX_BOOL				m_bLoaded;
+    bool				m_bLoaded;
     CFX_PtrArray		m_FontFaces;
     FXFT_Library		m_FTLibrary;
     CFX_MapPtrToPtr		m_FamilyFonts;
diff --git a/core/src/fxge/android/fx_android_font.cpp b/core/src/fxge/android/fx_android_font.cpp
index 3e2fc45854..4f2bc15b2a 100644
--- a/core/src/fxge/android/fx_android_font.cpp
+++ b/core/src/fxge/android/fx_android_font.cpp
@@ -10,20 +10,20 @@ CFX_AndroidFontInfo::CFX_AndroidFontInfo()
     : m_pFontMgr(NULL)
 {
 }
-FX_BOOL CFX_AndroidFontInfo::Init(IFPF_FontMgr *pFontMgr)
+bool CFX_AndroidFontInfo::Init(IFPF_FontMgr *pFontMgr)
 {
     if (!pFontMgr) {
-        return FALSE;
+        return false;
     }
     pFontMgr->LoadSystemFonts();
     m_pFontMgr = pFontMgr;
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AndroidFontInfo::EnumFontList(CFX_FontMapper* pMapper)
+bool CFX_AndroidFontInfo::EnumFontList(CFX_FontMapper* pMapper)
 {
-    return FALSE;
+    return false;
 }
-void* CFX_AndroidFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* face, FX_BOOL& bExact)
+void* CFX_AndroidFontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* face, bool& bExact)
 {
     if (!m_pFontMgr) {
         return NULL;
@@ -57,21 +57,21 @@ FX_DWORD CFX_AndroidFontInfo::GetFontData(void* hFont, FX_DWORD table, uint8_t*
     }
     return ((IFPF_Font*)hFont)->GetFontData(table, buffer, size);
 }
-FX_BOOL CFX_AndroidFontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
+bool CFX_AndroidFontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
 {
     if (!hFont) {
-        return FALSE;
+        return false;
     }
     name = ((IFPF_Font*)hFont)->GetFamilyName();
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_AndroidFontInfo::GetFontCharset(void* hFont, int& charset)
+bool CFX_AndroidFontInfo::GetFontCharset(void* hFont, int& charset)
 {
     if (!hFont) {
-        return FALSE;
+        return false;
     }
     charset = ((IFPF_Font*)hFont)->GetCharset();
-    return FALSE;
+    return false;
 }
 void CFX_AndroidFontInfo::DeleteFont(void* hFont)
 {
diff --git a/core/src/fxge/android/fx_android_font.h b/core/src/fxge/android/fx_android_font.h
index 83c04a03a4..075b79e7f2 100644
--- a/core/src/fxge/android/fx_android_font.h
+++ b/core/src/fxge/android/fx_android_font.h
@@ -18,18 +18,18 @@ public:
         delete this;
     }
 
-    virtual	FX_BOOL		EnumFontList(CFX_FontMapper* pMapper);
+    virtual	bool		EnumFontList(CFX_FontMapper* pMapper);
 
-    virtual void*		MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* face, FX_BOOL& bExact);
+    virtual void*		MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* face, bool& bExact);
 
     virtual void*		GetFont(const FX_CHAR* face);
     virtual FX_DWORD	GetFontData(void* hFont, FX_DWORD table, uint8_t* buffer, FX_DWORD size);
-    virtual FX_BOOL		GetFaceName(void* hFont, CFX_ByteString& name);
-    virtual FX_BOOL		GetFontCharset(void* hFont, int& charset);
+    virtual bool		GetFaceName(void* hFont, CFX_ByteString& name);
+    virtual bool		GetFontCharset(void* hFont, int& charset);
 
     virtual void		DeleteFont(void* hFont);
     virtual void*       RetainFont(void* hFont);
-    FX_BOOL				Init(IFPF_FontMgr *pFontMgr);
+    bool				Init(IFPF_FontMgr *pFontMgr);
 protected:
     IFPF_FontMgr		*m_pFontMgr;
 };
diff --git a/core/src/fxge/apple/apple_int.h b/core/src/fxge/apple/apple_int.h
index 715e48d6c2..0e6c9d683f 100644
--- a/core/src/fxge/apple/apple_int.h
+++ b/core/src/fxge/apple/apple_int.h
@@ -51,7 +51,7 @@ public:
     void*	CreateFont(const uint8_t* pFontData, FX_DWORD dwFontSize);
     void	DestroyFont(void* pFont);
     void	setGraphicsTextMatrix(void* graphics, CFX_AffineMatrix* matrix);
-    FX_BOOL	drawGraphicsString(void*                graphics,
+    bool	drawGraphicsString(void*                graphics,
                                void*                font,
                                FX_FLOAT             fontSize,
                                FX_WORD*             glyphIndices,
@@ -92,26 +92,26 @@ public:
     {
         return NULL;
     }
-    virtual FX_BOOL IsPSPrintDriver()
+    virtual bool IsPSPrintDriver()
     {
-        return FALSE;
+        return false;
     }
-    virtual FX_BOOL	StartRendering()
+    virtual bool	StartRendering()
     {
-        return TRUE;
+        return true;
     }
     virtual void	EndRendering() {}
     virtual void	SaveState();
-    virtual void	RestoreState(FX_BOOL bKeepSaved);
-    virtual FX_BOOL	SetClip_PathFill(const CFX_PathData* pPathData,
+    virtual void	RestoreState(bool bKeepSaved);
+    virtual bool	SetClip_PathFill(const CFX_PathData* pPathData,
                                      const CFX_AffineMatrix* pObject2Device,
                                      int fill_mode
                                     );
-    virtual FX_BOOL	SetClip_PathStroke(const CFX_PathData* pPathData,
+    virtual bool	SetClip_PathStroke(const CFX_PathData* pPathData,
                                        const CFX_AffineMatrix* pObject2Device,
                                        const CFX_GraphStateData* pGraphState
                                       );
-    virtual FX_BOOL	DrawPath(const CFX_PathData* pPathData,
+    virtual bool	DrawPath(const CFX_PathData* pPathData,
                              const CFX_AffineMatrix* pObject2Device,
                              const CFX_GraphStateData* pGraphState,
                              FX_DWORD fill_color,
@@ -121,36 +121,36 @@ public:
                              void* pIccTransform = NULL,
                              int blend_type = FXDIB_BLEND_NORMAL
                             );
-    virtual FX_BOOL	SetPixel(int x, int y, FX_DWORD color,
+    virtual bool	SetPixel(int x, int y, FX_DWORD color,
                              int alpha_flag = 0, void* pIccTransform = NULL)
     {
-        return FALSE;
+        return false;
     }
-    virtual FX_BOOL FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
+    virtual bool FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
                              int alpha_flag = 0, void* pIccTransform = NULL, int blend_type = FXDIB_BLEND_NORMAL);
-    virtual FX_BOOL	DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+    virtual bool	DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
                                      int alpha_flag = 0, void* pIccTransform = NULL, int blend_type = FXDIB_BLEND_NORMAL);
-    virtual FX_BOOL GetClipBox(FX_RECT* pRect);
-    virtual FX_BOOL	GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, FX_BOOL bDEdge = FALSE);
-    virtual FX_BOOL	SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect,
+    virtual bool GetClipBox(FX_RECT* pRect);
+    virtual bool	GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, bool bDEdge = false);
+    virtual bool	SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect,
                               int dest_left, int dest_top, int blend_type,
                               int alpha_flag = 0, void* pIccTransform = NULL);
-    virtual FX_BOOL	StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+    virtual bool	StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                   int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                   int alpha_flag = 0, void* pIccTransform = NULL, int blend_type = FXDIB_BLEND_NORMAL);
-    virtual FX_BOOL	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+    virtual bool	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                 const CFX_AffineMatrix* pMatrix, FX_DWORD flags, void*& handle,
                                 int alpha_flag = 0, void* pIccTransform = NULL,
                                 int blend_type = FXDIB_BLEND_NORMAL)
     {
-        return FALSE;
+        return false;
     }
-    virtual FX_BOOL	ContinueDIBits(void* handle, IFX_Pause* pPause)
+    virtual bool	ContinueDIBits(void* handle, IFX_Pause* pPause)
     {
-        return FALSE;
+        return false;
     }
     virtual void	CancelDIBits(void* handle) {}
-    virtual FX_BOOL DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+    virtual bool DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
                                    CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
                                    int alpha_flag = 0, void* pIccTransform = NULL);
     virtual void    ClearDriver();
@@ -159,7 +159,7 @@ protected:
     void setFillInfo(FX_ARGB argb);
     void setPathToContext(const CFX_PathData * pathData);
     FX_FLOAT getLineWidth(const CFX_GraphStateData * graphState, CGAffineTransform ctm);
-    FX_BOOL CG_DrawGlypRun(int                        nChars,
+    bool CG_DrawGlypRun(int                        nChars,
                            const FXTEXT_CHARPOS*      pCharPos,
                            CFX_Font*                  pFont,
                            CFX_FontCache*             pCache,
@@ -195,9 +195,9 @@ public:
     {
         return (FX_FILESIZE)_totalSize;
     }
-    virtual FX_BOOL			ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override;
+    virtual bool			ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override;
 
-    virtual FX_BOOL			IsEOF() override
+    virtual bool			IsEOF() override
     {
         return _offSet == _totalSize;
     }
diff --git a/core/src/fxge/apple/fx_apple_platform.cpp b/core/src/fxge/apple/fx_apple_platform.cpp
index 9db807c3af..9f4712bf7e 100644
--- a/core/src/fxge/apple/fx_apple_platform.cpp
+++ b/core/src/fxge/apple/fx_apple_platform.cpp
@@ -39,7 +39,7 @@ CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph_Nativetext(CFX_Font *				pFont,
 {
     return NULL;
 }
-static FX_BOOL _CGDrawGlyphRun(CGContextRef               pContext,
+static bool _CGDrawGlyphRun(CGContextRef               pContext,
                                int                        nChars,
                                const FXTEXT_CHARPOS*      pCharPos,
                                CFX_Font*                  pFont,
@@ -51,10 +51,10 @@ static FX_BOOL _CGDrawGlyphRun(CGContextRef               pContext,
                                void*                      pIccTransform)
 {
     if (nChars == 0) {
-        return TRUE;
+        return true;
     }
     CFX_AffineMatrix new_matrix;
-    FX_BOOL bNegSize = font_size < 0;
+    bool bNegSize = font_size < 0;
     if (bNegSize) {
         font_size = -font_size;
     }
@@ -66,11 +66,11 @@ static FX_BOOL _CGDrawGlyphRun(CGContextRef               pContext,
     CQuartz2D& quartz2d = ((CApplePlatform *) CFX_GEModule::Get()->GetPlatformData())->_quartz2d;
     if (!pFont->m_pPlatformFont) {
         if (pFont->GetPsName() == CFX_WideString::FromLocal("DFHeiStd-W5")) {
-            return FALSE;
+            return false;
         }
         pFont->m_pPlatformFont = quartz2d.CreateFont(pFont->m_pFontData, pFont->m_dwSize);
         if (NULL == pFont->m_pPlatformFont) {
-            return FALSE;
+            return false;
         }
     }
     CFX_FixedBufGrow<FX_WORD, 32> glyph_indices(nChars);
@@ -101,7 +101,7 @@ static FX_BOOL _CGDrawGlyphRun(CGContextRef               pContext,
                                        NULL);
 }
 static void _DoNothing(void *info, const void *data, size_t size) {}
-FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int						 nChars,
+bool CFX_AggDeviceDriver::DrawDeviceText(int						 nChars,
         const FXTEXT_CHARPOS *	 pCharPos,
         CFX_Font *				 pFont,
         CFX_FontCache *			 pCache,
@@ -111,22 +111,22 @@ FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int						 nChars,
         int alpha_flag, void* pIccTransform)
 {
     if (!pFont) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL bBold = pFont->IsBold();
+    bool bBold = pFont->IsBold();
     if (!bBold && pFont->GetSubstFont() &&
             pFont->GetSubstFont()->m_Weight >= 500 &&
             pFont->GetSubstFont()->m_Weight <= 600) {
-        return FALSE;
+        return false;
     }
     for (int i = 0; i < nChars; i ++) {
         if (pCharPos[i].m_bGlyphAdjust) {
-            return FALSE;
+            return false;
         }
     }
     CGContextRef ctx = CGContextRef(m_pPlatformGraphics);
     if (NULL == ctx) {
-        return FALSE;
+        return false;
     }
     CGContextSaveGState(ctx);
     CGContextSetTextDrawingMode(ctx, kCGTextFillClip);
@@ -143,7 +143,7 @@ FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int						 nChars,
             CGFloat decode_f[2] = {255.f, 0.f};
             pImageCG = CGImageMaskCreate(pClipMask->GetWidth(), pClipMask->GetHeight(),
                                          8, 8, pClipMask->GetPitch(), pClipMaskDataProvider,
-                                         decode_f, FALSE);
+                                         decode_f, false);
             CGDataProviderRelease(pClipMaskDataProvider);
         }
     } else {
@@ -155,7 +155,7 @@ FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int						 nChars,
     } else {
         CGContextClipToRect(ctx, rect_cg);
     }
-    FX_BOOL ret = _CGDrawGlyphRun(ctx, nChars, pCharPos, pFont, pCache, pObject2Device, font_size, argb, alpha_flag, pIccTransform);
+    bool ret = _CGDrawGlyphRun(ctx, nChars, pCharPos, pFont, pCache, pObject2Device, font_size, argb, alpha_flag, pIccTransform);
     if (pImageCG) {
         CGImageRelease(pImageCG);
     }
diff --git a/core/src/fxge/apple/fx_mac_imp.cpp b/core/src/fxge/apple/fx_mac_imp.cpp
index 04b04b8ba8..5e5908b8ff 100644
--- a/core/src/fxge/apple/fx_mac_imp.cpp
+++ b/core/src/fxge/apple/fx_mac_imp.cpp
@@ -28,7 +28,7 @@ Base14Substs[] = {
 class CFX_MacFontInfo : public CFX_FolderFontInfo
 {
 public:
-    virtual void*		MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, FX_BOOL& bExact);
+    virtual void*		MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, bool& bExact);
 };
 #define JAPAN_GOTHIC "Hiragino Kaku Gothic Pro W6"
 #define JAPAN_MINCHO "Hiragino Mincho Pro W6"
@@ -44,14 +44,14 @@ static void GetJapanesePreference(CFX_ByteString& face, int weight, int picth_fa
         face = JAPAN_MINCHO;
     }
 }
-void* CFX_MacFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, FX_BOOL& bExact)
+void* CFX_MacFontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, bool& bExact)
 {
     CFX_ByteString face = cstr_face;
     int iBaseFont;
     for (iBaseFont = 0; iBaseFont < 12; iBaseFont ++)
         if (face == CFX_ByteStringC(Base14Substs[iBaseFont].m_pName)) {
             face = Base14Substs[iBaseFont].m_pSubstName;
-            bExact = TRUE;
+            bExact = true;
             break;
         }
     if (iBaseFont < 12) {
diff --git a/core/src/fxge/apple/fx_quartz_device.cpp b/core/src/fxge/apple/fx_quartz_device.cpp
index d1e4f544ba..8aa689fa91 100644
--- a/core/src/fxge/apple/fx_quartz_device.cpp
+++ b/core/src/fxge/apple/fx_quartz_device.cpp
@@ -76,7 +76,7 @@ void CQuartz2D::setGraphicsTextMatrix(void* graphics, CFX_AffineMatrix* matrix)
                            matrix->e,
                            ty));
 }
-FX_BOOL CQuartz2D::drawGraphicsString(void*                 graphics,
+bool CQuartz2D::drawGraphicsString(void*                 graphics,
                                       void*                 font,
                                       FX_FLOAT              fontSize,
                                       FX_WORD*              glyphIndices,
@@ -86,7 +86,7 @@ FX_BOOL CQuartz2D::drawGraphicsString(void*                 graphics,
                                       CFX_AffineMatrix*     matrix )
 {
     if (!graphics) {
-        return FALSE;
+        return false;
     }
     CGContextRef context = (CGContextRef) graphics;
     CGContextSetFont(context, (CGFontRef)font);
@@ -113,7 +113,7 @@ FX_BOOL CQuartz2D::drawGraphicsString(void*                 graphics,
 #if CGFLOAT_IS_DOUBLE
     CGPoint* glyphPositionsCG = new CGPoint[charsCount];
     if (!glyphPositionsCG) {
-        return FALSE;
+        return false;
     }
     for (int index = 0; index < charsCount; ++index) {
         glyphPositionsCG[index].x = glyphPositions[index].x;
@@ -130,7 +130,7 @@ FX_BOOL CQuartz2D::drawGraphicsString(void*                 graphics,
     delete[] glyphPositionsCG;
 #endif
     CGContextRestoreGState(context);
-    return TRUE;
+    return true;
 }
 void CQuartz2D::saveGraphicsState(void * graphics)
 {
@@ -251,7 +251,7 @@ void CFX_QuartzDeviceDriver::SaveState()
     CGContextSaveGState(_context);
     m_saveCount++;
 }
-void CFX_QuartzDeviceDriver::RestoreState(FX_BOOL isKeepSaved )
+void CFX_QuartzDeviceDriver::RestoreState(bool isKeepSaved )
 {
     CGContextRestoreGState(_context);
     if (isKeepSaved) {
@@ -260,7 +260,7 @@ void CFX_QuartzDeviceDriver::RestoreState(FX_BOOL isKeepSaved )
         m_saveCount--;
     }
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData*    pathData,
+bool CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData*    pathData,
         const CFX_AffineMatrix*   matrix,
         int                       fillMode )
 {
@@ -272,13 +272,13 @@ FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData*    pathData
     m = CGAffineTransformConcat(m, _foxitDevice2User);
     CGContextConcatCTM(_context, m);
     setPathToContext(pathData);
-    RestoreState(FALSE);
+    RestoreState(false);
     if ((fillMode & 3) == FXFILL_WINDING) {
         CGContextClip(_context);
     } else {
         CGContextEOClip(_context);
     }
-    return TRUE;
+    return true;
 }
 FX_FLOAT CFX_QuartzDeviceDriver::getLineWidth(const CFX_GraphStateData * graphState, CGAffineTransform ctm)
 {
@@ -294,7 +294,7 @@ FX_FLOAT CFX_QuartzDeviceDriver::getLineWidth(const CFX_GraphStateData * graphSt
     }
     return lineWidth;
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData*      pathData,
+bool CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData*      pathData,
         const CFX_AffineMatrix*     matrix,
         const CFX_GraphStateData*   graphState )
 {
@@ -309,9 +309,9 @@ FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData*      path
     setStrokeInfo(graphState, 0xFF000000, lineWidth);
     setPathToContext(pathData);
     CGContextReplacePathWithStrokedPath(_context);
-    RestoreState(FALSE);
+    RestoreState(false);
     CGContextClip(_context);
-    return TRUE;
+    return true;
 }
 static CGBlendMode GetCGBlendMode(int blend_type)
 {
@@ -371,7 +371,7 @@ static CGBlendMode GetCGBlendMode(int blend_type)
     }
     return mode;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData*        pathData,
+bool CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData*        pathData,
         const CFX_AffineMatrix*       matrix,
         const CFX_GraphStateData*     graphState,
         FX_DWORD                      fillArgb,
@@ -423,10 +423,10 @@ FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData*        pathData,
     } else if (pathMode == 6) {
         CGContextDrawPath(_context, kCGPathEOFillStroke);
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::FillRect(const FX_RECT*         rect,
+bool CFX_QuartzDeviceDriver::FillRect(const FX_RECT*         rect,
         FX_ARGB                   fillArgb,
         int                       alphaFlag	   ,
         void*                     iccTransform ,
@@ -449,9 +449,9 @@ FX_BOOL CFX_QuartzDeviceDriver::FillRect(const FX_RECT*         rect,
     if (mode != kCGBlendModeNormal) {
         CGContextSetBlendMode(_context, kCGBlendModeNormal);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT           x1,
+bool CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT           x1,
         FX_FLOAT              y1,
         FX_FLOAT              x2,
         FX_FLOAT              y2,
@@ -483,9 +483,9 @@ FX_BOOL CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT           x1,
     if (mode != kCGBlendModeNormal) {
         CGContextSetBlendMode(_context, kCGBlendModeNormal);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect)
+bool CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect)
 {
     CGRect r = CGContextGetClipBoundingBox(_context);
     r = CGRectApplyAffineTransform(r, _user2FoxitDevice);
@@ -493,22 +493,22 @@ FX_BOOL CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect)
     rect->top		= FXSYS_floor(r.origin.y);
     rect->right		= FXSYS_ceil(r.origin.x + r.size.width);
     rect->bottom	= FXSYS_ceil(r.origin.y + r.size.height);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
+bool CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
         int32_t            left,
         int32_t            top,
         void* pIccTransform,
-        FX_BOOL bDEdge)
+        bool bDEdge)
 {
     if (FXDC_PRINTER == _deviceClass) {
-        return FALSE;
+        return false;
     }
     if (bitmap->GetBPP() < 32) {
-        return FALSE;
+        return false;
     }
     if (!(_renderCaps | FXRC_GET_BITS)) {
-        return FALSE;
+        return false;
     }
     CGPoint pt = CGPointMake(left, top);
     pt = CGPointApplyAffineTransform(pt, _foxitDevice2User);
@@ -517,7 +517,7 @@ FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
     pt.y *= FXSYS_fabs(ctm.d);
     CGImageRef image = CGBitmapContextCreateImage(_context);
     if (NULL == image) {
-        return FALSE;
+        return false;
     }
     CGFloat width	= (CGFloat) bitmap->GetWidth();
     CGFloat height	= (CGFloat) bitmap->GetHeight();
@@ -552,9 +552,9 @@ FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
+bool CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
         FX_ARGB                     argb,
         const FX_RECT*              srcRect,
         int                         dest_left,
@@ -598,8 +598,8 @@ FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
             pBitmap1 = pBitmap->Clone();
         }
         if (NULL == pBitmap1) {
-            RestoreState(FALSE);
-            return FALSE;
+            RestoreState(false);
+            return false;
         }
         CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
                                             pBitmap1->GetBuffer(),
@@ -629,8 +629,8 @@ FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
         if (pBitmap1 != pBitmap) {
             delete pBitmap1;
         }
-        RestoreState(FALSE);
-        return TRUE;
+        RestoreState(false);
+        return true;
     }
     if (pBitmap->GetBPP() < 32) {
         pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
@@ -642,15 +642,15 @@ FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
         }
     }
     if (NULL == pBitmap1) {
-        RestoreState(FALSE);
-        return FALSE;
+        RestoreState(false);
+        return false;
     }
     if (pBitmap1->HasAlpha()) {
         if (pBitmap1 == pBitmap) {
             pBitmap1 = pBitmap->Clone();
             if (!pBitmap1) {
-                RestoreState(FALSE);
-                return FALSE;
+                RestoreState(false);
+                return false;
             }
         }
         for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
@@ -682,10 +682,10 @@ FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
     if (pBitmap1 != pBitmap) {
         delete pBitmap1;
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
+bool CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
         FX_ARGB                     argb,
         int                         dest_left,
         int                         dest_top,
@@ -723,8 +723,8 @@ FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
             pBitmap1 = pBitmap->Clone();
         }
         if (NULL == pBitmap1) {
-            RestoreState(FALSE);
-            return FALSE;
+            RestoreState(false);
+            return false;
         }
         CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
                                             pBitmap1->GetBuffer(),
@@ -754,8 +754,8 @@ FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
         if (pBitmap1 != pBitmap) {
             delete pBitmap1;
         }
-        RestoreState(FALSE);
-        return TRUE;
+        RestoreState(false);
+        return true;
     }
     if (pBitmap->GetBPP() < 32) {
         pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
@@ -767,15 +767,15 @@ FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
         }
     }
     if (NULL == pBitmap1) {
-        RestoreState(FALSE);
-        return FALSE;
+        RestoreState(false);
+        return false;
     }
     if (pBitmap1->HasAlpha()) {
         if (pBitmap1 == pBitmap) {
             pBitmap1 = pBitmap->Clone();
             if (!pBitmap1) {
-                RestoreState(FALSE);
-                return FALSE;
+                RestoreState(false);
+                return false;
             }
         }
         for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
@@ -796,10 +796,10 @@ FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
     if (pBitmap1 != pBitmap) {
         delete pBitmap1;
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars,
+bool CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars,
         const FXTEXT_CHARPOS*      pCharPos,
         CFX_Font*                  pFont,
         CFX_FontCache*             pCache,
@@ -811,16 +811,16 @@ FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars
         void*                      pIccTransform)
 {
     if (nChars == 0) {
-        return TRUE;
+        return true;
     }
     CQuartz2D& quartz2d = ((CApplePlatform *) CFX_GEModule::Get()->GetPlatformData())->_quartz2d;
     if (!pFont->m_pPlatformFont) {
         if (pFont->GetPsName() == CFX_WideString::FromLocal("DFHeiStd-W5")) {
-            return FALSE;
+            return false;
         }
         pFont->m_pPlatformFont = quartz2d.CreateFont(pFont->m_pFontData, pFont->m_dwSize);
         if (NULL == pFont->m_pPlatformFont) {
-            return FALSE;
+            return false;
         }
     }
     CFX_FixedBufGrow<FX_WORD, 32> glyph_indices(nChars);
@@ -872,10 +872,10 @@ FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars
                                    (CGGlyph*)glyph_indices,
                                    glyph_positions,
                                    nChars);
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
+bool CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
         const FXTEXT_CHARPOS*    pCharPos,
         CFX_Font*                pFont,
         CFX_FontCache*           pCache,
@@ -886,24 +886,24 @@ FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
         void*                    pIccTransform)
 {
     if (NULL == pFont || NULL == _context) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL bBold = pFont->IsBold();
+    bool bBold = pFont->IsBold();
     if (!bBold && pFont->GetSubstFont() &&
             pFont->GetSubstFont()->m_Weight >= 500 &&
             pFont->GetSubstFont()->m_Weight <= 600) {
-        return FALSE;
+        return false;
     }
     SaveState();
     CGContextSetTextDrawingMode(_context, kCGTextFillClip);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     int32_t i = 0;
     while (i < nChars) {
         if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
             if (i > 0) {
                 ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device, font_size, color, alpha_flag, pIccTransform);
                 if (!ret) {
-                    RestoreState(FALSE);
+                    RestoreState(false);
                     return ret;
                 }
             }
@@ -920,7 +920,7 @@ FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
             }
             ret = CG_DrawGlypRun(1, char_pos, pFont, pCache, &glphy_matrix, pObject2Device, font_size, color, alpha_flag, pIccTransform);
             if (!ret) {
-                RestoreState(FALSE);
+                RestoreState(false);
                 return ret;
             }
             i ++;
@@ -934,7 +934,7 @@ FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
     if (i > 0) {
         ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device, font_size, color, alpha_flag, pIccTransform);
     }
-    RestoreState(FALSE);
+    RestoreState(false);
     return ret;
 }
 void CFX_QuartzDeviceDriver::setStrokeInfo(const CFX_GraphStateData* graphState, FX_ARGB argb, FX_FLOAT lineWidth)
@@ -1074,7 +1074,7 @@ void CFX_QuartzDeviceDriver::ClearDriver()
 }
 CFX_QuartzDevice::CFX_QuartzDevice()
 {
-    m_bOwnedBitmap = FALSE;
+    m_bOwnedBitmap = false;
     m_pContext = NULL;
 }
 CFX_QuartzDevice::~CFX_QuartzDevice()
@@ -1090,7 +1090,7 @@ CGContextRef CFX_QuartzDevice::GetContext()
 {
     return m_pContext;
 }
-FX_BOOL CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass)
+bool CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass)
 {
     if (m_pContext) {
         CGContextRelease(m_pContext);
@@ -1099,30 +1099,30 @@ FX_BOOL CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass)
     CGContextRetain(m_pContext);
     IFX_RenderDeviceDriver* pDriver = new CFX_QuartzDeviceDriver(m_pContext, nDeviceClass);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap)
+bool CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap)
 {
     SetBitmap(pBitmap);
     m_pContext = createContextWithBitmap(pBitmap);
     if (NULL == m_pContext) {
-        return FALSE;
+        return false;
     }
     IFX_RenderDeviceDriver* pDriver = new CFX_QuartzDeviceDriver(m_pContext, FXDC_DISPLAY);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDevice::Create(int32_t width, int32_t height, FXDIB_Format format)
+bool CFX_QuartzDevice::Create(int32_t width, int32_t height, FXDIB_Format format)
 {
     if ((uint8_t)format < 32) {
-        return FALSE;
+        return false;
     }
     CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
     if (!pBitmap->Create(width, height, format)) {
         delete pBitmap;
-        return FALSE;
+        return false;
     }
-    m_bOwnedBitmap = TRUE;
+    m_bOwnedBitmap = true;
     return Attach(pBitmap);
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
diff --git a/core/src/fxge/dib/dib_int.h b/core/src/fxge/dib/dib_int.h
index 825cabe1d1..a6834fd641 100644
--- a/core/src/fxge/dib/dib_int.h
+++ b/core/src/fxge/dib/dib_int.h
@@ -63,7 +63,7 @@ public:
                    int dest_width, int dest_height, const FX_RECT& clip_rect,
                    const CFX_DIBSource* pSrcBitmap, int flags);
     ~CStretchEngine();
-    FX_BOOL		Continue(IFX_Pause* pPause);
+    bool		Continue(IFX_Pause* pPause);
 public:
     FXDIB_Format m_DestFormat;
     int		m_DestBpp, m_SrcBpp, m_bHasAlpha;
@@ -84,8 +84,8 @@ public:
     int 	m_Flags;
     CWeightTable	m_WeightTable;
     int		m_CurRow;
-    FX_BOOL	StartStretchHorz();
-    FX_BOOL	ContinueStretchHorz(IFX_Pause* pPause);
+    bool	StartStretchHorz();
+    bool	ContinueStretchHorz(IFX_Pause* pPause);
     void	StretchVert();
     int		m_State;
 };
diff --git a/core/src/fxge/dib/fx_dib_composite.cpp b/core/src/fxge/dib/fx_dib_composite.cpp
index cb99a37ff4..9f454cc31d 100644
--- a/core/src/fxge/dib/fx_dib_composite.cpp
+++ b/core/src/fxge/dib/fx_dib_composite.cpp
@@ -272,7 +272,7 @@ void _CompositeRow_Argb2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int p
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         if (src_alpha_scan) {
             for (int col = 0; col < pixel_count; col ++) {
@@ -467,7 +467,7 @@ inline void _CompositeRow_Argb2Gray(uint8_t* dest_scan, const uint8_t* src_scan,
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         if (src_alpha_scan) {
             for (int col = 0; col < pixel_count; col ++) {
@@ -558,7 +558,7 @@ inline void _CompositeRow_Rgb2Gray(uint8_t* dest_scan, const uint8_t* src_scan,
         pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     }
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             if (pIccTransform) {
@@ -605,7 +605,7 @@ void _CompositeRow_Rgb2Graya(uint8_t* dest_scan, const uint8_t* src_scan, int sr
     }
     if (blend_type) {
         int blended_color;
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         for (int col = 0; col < pixel_count; col ++) {
             int back_alpha = *dest_alpha_scan;
             if (back_alpha == 0) {
@@ -689,7 +689,7 @@ void _CompositeRow_Argb2Argb(uint8_t* dest_scan, const uint8_t* src_scan, int pi
                              uint8_t* dest_alpha_scan, const uint8_t* src_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     if (dest_alpha_scan == NULL) {
         if (src_alpha_scan == NULL) {
             uint8_t back_alpha = 0;
@@ -896,7 +896,7 @@ void _CompositeRow_Rgb2Argb_Blend_NoClip(uint8_t* dest_scan, const uint8_t* src_
         uint8_t* dest_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
@@ -957,7 +957,7 @@ inline void _CompositeRow_Rgb2Argb_Blend_Clip(uint8_t* dest_scan, const uint8_t*
         uint8_t* dest_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     if (dest_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
@@ -1121,7 +1121,7 @@ inline void _CompositeRow_Argb2Rgb_Blend(uint8_t* dest_scan, const uint8_t* src_
         const uint8_t* src_alpha_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     if (src_alpha_scan == NULL) {
         for (int col = 0; col < width; col ++) {
@@ -1243,7 +1243,7 @@ inline void _CompositeRow_Argb2Rgb_NoBlend(uint8_t* dest_scan, const uint8_t* sr
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
@@ -1266,7 +1266,7 @@ inline void _CompositeRow_Rgb2Rgb_Blend_NoClip(uint8_t* dest_scan, const uint8_t
 inline void _CompositeRow_Rgb2Rgb_Blend_Clip(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int dest_gap = dest_Bpp - 3;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
@@ -1357,7 +1357,7 @@ void _CompositeRow_Argb2Argb_Transform(uint8_t* dest_scan, const uint8_t* src_sc
             }
         } else {
             int blended_colors[3];
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             for (int col = 0; col < pixel_count; col ++) {
                 pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
                 uint8_t back_alpha = *dest_alpha_scan;
@@ -1487,7 +1487,7 @@ inline void _CompositeRow_Argb2Rgb_Blend_Transform(uint8_t* dest_scan, const uin
         pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, width);
     } else {
         int blended_colors[3];
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int dest_gap = dest_Bpp - 3;
         for (int col = 0; col < width; col ++) {
             pIccModule->TranslateScanline(pIccTransform, src_cache_scan, src_scan, 1);
@@ -1630,7 +1630,7 @@ inline void _CompositeRow_8bppPal2Gray(uint8_t* dest_scan, const uint8_t* src_sc
 {
     if (src_alpha_scan) {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
@@ -1668,7 +1668,7 @@ inline void _CompositeRow_8bppPal2Gray(uint8_t* dest_scan, const uint8_t* src_sc
         }
     } else {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
@@ -1704,7 +1704,7 @@ inline void _CompositeRow_8bppPal2Graya(uint8_t* dest_scan, const uint8_t* src_s
 {
     if (src_alpha_scan) {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
@@ -1778,7 +1778,7 @@ inline void _CompositeRow_8bppPal2Graya(uint8_t* dest_scan, const uint8_t* src_s
         }
     } else {
         if (blend_type) {
-            FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+            bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
             int blended_color;
             for (int col = 0; col < pixel_count; col ++) {
                 uint8_t gray = pPalette[*src_scan];
@@ -1836,7 +1836,7 @@ inline void _CompositeRow_1bppPal2Gray(uint8_t* dest_scan, const uint8_t* src_sc
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
@@ -1870,7 +1870,7 @@ inline void _CompositeRow_1bppPal2Graya(uint8_t* dest_scan, const uint8_t* src_s
     int reset_gray = pPalette[0];
     int set_gray = pPalette[1];
     if (blend_type) {
-        FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+        bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
         int blended_color;
         for (int col = 0; col < pixel_count; col ++) {
             uint8_t gray = (src_scan[(col + src_left) / 8] & (1 << (7 - (col + src_left) % 8))) ? set_gray : reset_gray;
@@ -2787,7 +2787,7 @@ void _CompositeRow_BitMask2Graya(uint8_t* dest_scan, const uint8_t* src_scan, in
 void _CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int pixel_count, int blend_type, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < pixel_count; col ++) {
         uint8_t back_alpha = dest_scan[3];
         if (back_alpha == 0) {
@@ -2844,7 +2844,7 @@ void _CompositeRow_Argb2Argb_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src
 void _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t back_alpha = dest_scan[3];
@@ -2881,7 +2881,7 @@ void _CompositeRow_Rgb2Argb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, const
 inline void _CompositeRow_Argb2Rgb_Blend_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha;
         if (clip_scan) {
@@ -2928,7 +2928,7 @@ inline void _CompositeRow_Rgb2Argb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_sca
 inline void _CompositeRow_Rgb2Rgb_Blend_NoClip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         if (bNonseparableBlend) {
@@ -2995,7 +2995,7 @@ inline void _CompositeRow_Rgb2Rgb_NoBlend_NoClip_RgbByteOrder(uint8_t* dest_scan
 inline void _CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         int src_alpha = *clip_scan ++;
@@ -3039,7 +3039,7 @@ inline void _CompositeRow_Rgb2Argb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, c
 inline void _CompositeRow_Rgb2Rgb_Blend_Clip_RgbByteOrder(uint8_t* dest_scan, const uint8_t* src_scan, int width, int blend_type, int dest_Bpp, int src_Bpp, const uint8_t* clip_scan)
 {
     int blended_colors[3];
-    FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
+    bool bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int src_gap = src_Bpp - 3;
     for (int col = 0; col < width; col ++) {
         uint8_t src_alpha = *clip_scan ++;
@@ -3495,7 +3495,7 @@ void _CompositeRow_BitMask2Rgb_RgbByteOrder(uint8_t* dest_scan, const uint8_t* s
         dest_scan += Bpp;
     }
 }
-inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int alpha_flag, FX_DWORD mask_color, int& mask_alpha,
+inline bool _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int alpha_flag, FX_DWORD mask_color, int& mask_alpha,
         int& mask_red, int& mask_green, int& mask_blue, int& mask_black,
         void* icc_module, void* pIccTransform)
 {
@@ -3513,7 +3513,7 @@ inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int
         mask_blue = FXARGB_B(mask_color);
     }
     if (dest_format == FXDIB_8bppMask) {
-        return TRUE;
+        return true;
     }
     if ((dest_format & 0xff) == 8) {
         if (pIccTransform) {
@@ -3550,15 +3550,15 @@ inline FX_BOOL _ScanlineCompositor_InitSourceMask(FXDIB_Format dest_format, int
             mask_blue = mask_color_p[0];
         }
     }
-    return TRUE;
+    return true;
 }
 inline void _ScanlineCompositor_InitSourcePalette(FXDIB_Format src_format, FXDIB_Format dest_format,
         FX_DWORD*& pDestPalette, FX_DWORD* pSrcPalette,
         void* icc_module, void* pIccTransform)
 {
     ICodec_IccModule* pIccModule = (ICodec_IccModule*)icc_module;
-    FX_BOOL isSrcCmyk = src_format & 0x0400 ? TRUE : FALSE;
-    FX_BOOL isDstCmyk = dest_format & 0x0400 ? TRUE : FALSE;
+    bool isSrcCmyk = src_format & 0x0400 ? true : false;
+    bool isDstCmyk = dest_format & 0x0400 ? true : false;
     pDestPalette = NULL;
     if (pIccTransform) {
         if (pSrcPalette) {
@@ -3679,7 +3679,7 @@ CFX_ScanlineCompositor::CFX_ScanlineCompositor()
     m_pSrcPalette = NULL;
     m_pCacheScanline = NULL;
     m_CacheSize = 0;
-    m_bRgbByteOrder = FALSE;
+    m_bRgbByteOrder = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ScanlineCompositor::~CFX_ScanlineCompositor()
@@ -3691,8 +3691,8 @@ CFX_ScanlineCompositor::~CFX_ScanlineCompositor()
         FX_Free(m_pCacheScanline);
     }
 }
-FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_format, int32_t width, FX_DWORD* pSrcPalette,
-                                     FX_DWORD mask_color, int blend_type, FX_BOOL bClip, FX_BOOL bRgbByteOrder, int alpha_flag, void* pIccTransform)
+bool CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_format, int32_t width, FX_DWORD* pSrcPalette,
+                                     FX_DWORD mask_color, int blend_type, bool bClip, bool bRgbByteOrder, int alpha_flag, void* pIccTransform)
 {
     m_SrcFormat = src_format;
     m_DestFormat = dest_format;
@@ -3707,7 +3707,7 @@ FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_
     }
     m_pIccTransform = pIccTransform;
     if ((dest_format & 0xff) == 1) {
-        return FALSE;
+        return false;
     }
     if (m_SrcFormat == FXDIB_1bppMask || m_SrcFormat == FXDIB_8bppMask) {
         return _ScanlineCompositor_InitSourceMask(dest_format, alpha_flag, mask_color,
@@ -3715,11 +3715,11 @@ FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_
                 pIccModule, pIccTransform);
     }
     if (pIccTransform == NULL && (~src_format & 0x0400) && (dest_format & 0x0400)) {
-        return FALSE;
+        return false;
     }
     if ((m_SrcFormat & 0xff) <= 8) {
         if (dest_format == FXDIB_8bppMask) {
-            return TRUE;
+            return true;
         }
         _ScanlineCompositor_InitSourcePalette(src_format, dest_format, m_pSrcPalette, pSrcPalette,
                                               pIccModule, pIccTransform);
@@ -3727,7 +3727,7 @@ FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_
                          + (dest_format & 0x0200 ? 2 : 0)
                          + (dest_format & 0x0400 ? 4 : 0)
                          + ((src_format & 0xff) == 1 ? 8 : 0);
-        return TRUE;
+        return true;
     }
     m_Transparency = (src_format & 0x0200 ? 0 : 1)
                      + (dest_format & 0x0200 ? 0 : 2)
@@ -3736,7 +3736,7 @@ FX_BOOL CFX_ScanlineCompositor::Init(FXDIB_Format dest_format, FXDIB_Format src_
                      + (src_format & 0x0400 ? 16 : 0)
                      + (dest_format & 0x0400 ? 32 : 0)
                      + (pIccTransform ? 64 : 0);
-    return TRUE;
+    return true;
 }
 void CFX_ScanlineCompositor::CompositeRgbBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int width, const uint8_t* clip_scan,
         const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
@@ -4059,22 +4059,22 @@ void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan, const uint
         _CompositeRow_BitMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
                                   src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
 }
-FX_BOOL CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top,
-                                      int blend_type, const CFX_ClipRgn* pClipRgn, FX_BOOL bRgbByteOrder, void* pIccTransform)
+                                      int blend_type, const CFX_ClipRgn* pClipRgn, bool bRgbByteOrder, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(!pSrcBitmap->IsAlphaMask());
     ASSERT(m_bpp >= 8);
     if (pSrcBitmap->IsAlphaMask() || m_bpp < 8) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(),
                    src_left, src_top, pClipRgn);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     const CFX_DIBitmap* pClipMask = NULL;
     FX_RECT clip_box;
@@ -4086,11 +4086,11 @@ FX_BOOL CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, in
     CFX_ScanlineCompositor compositor;
     if (!compositor.Init(GetFormat(), pSrcBitmap->GetFormat(), width, pSrcBitmap->GetPalette(), 0, blend_type,
                          pClipMask != NULL, bRgbByteOrder, 0, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     int dest_Bpp = m_bpp / 8;
     int src_Bpp = pSrcBitmap->GetBPP() / 8;
-    FX_BOOL bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
+    bool bRgb = src_Bpp > 1 && !pSrcBitmap->IsCmykImage();
     CFX_DIBitmap* pSrcAlphaMask = pSrcBitmap->m_pAlphaMask;
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * dest_Bpp;
@@ -4107,27 +4107,27 @@ FX_BOOL CFX_DIBitmap::CompositeBitmap(int dest_left, int dest_top, int width, in
             compositor.CompositePalBitmapLine(dest_scan, src_scan, src_left, width, clip_scan, src_scan_extra_alpha, dst_scan_extra_alpha);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int height,
                                     const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top,
-                                    int blend_type, const CFX_ClipRgn* pClipRgn, FX_BOOL bRgbByteOrder, int alpha_flag, void* pIccTransform)
+                                    int blend_type, const CFX_ClipRgn* pClipRgn, bool bRgbByteOrder, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(pMask->IsAlphaMask());
     ASSERT(m_bpp >= 8);
     if (!pMask->IsAlphaMask() || m_bpp < 8) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, pClipRgn);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     int src_alpha = (uint8_t)(alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
     if (src_alpha == 0) {
-        return TRUE;
+        return true;
     }
     const CFX_DIBitmap* pClipMask = NULL;
     FX_RECT clip_box;
@@ -4140,7 +4140,7 @@ FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int
     int Bpp = GetBPP() / 8;
     CFX_ScanlineCompositor compositor;
     if (!compositor.Init(GetFormat(), pMask->GetFormat(), width, NULL, color, blend_type, pClipMask != NULL, bRgbByteOrder, alpha_flag, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     for (int row = 0; row < height; row ++) {
         uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
@@ -4156,21 +4156,21 @@ FX_BOOL CFX_DIBitmap::CompositeMask(int dest_left, int dest_top, int width, int
             compositor.CompositeByteMaskLine(dest_scan, src_scan + src_left, width, clip_scan, dst_scan_extra_alpha);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX_DWORD color, int alpha_flag, void* pIccTransform)
+bool CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     int src_alpha = (alpha_flag >> 8) ? (alpha_flag & 0xff) : FXARGB_A(color);
     if (src_alpha == 0) {
-        return TRUE;
+        return true;
     }
     FX_RECT rect(left, top, left + width, top + height);
     rect.Intersect(0, 0, m_Width, m_Height);
     if (rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     width = rect.Width();
     FX_DWORD dst_color;
@@ -4210,7 +4210,7 @@ FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX
                     dest_scan ++;
                 }
         }
-        return TRUE;
+        return true;
     }
     if (m_bpp == 1) {
         ASSERT(!IsCmykImage() && (uint8_t)(alpha_flag >> 8) == 0);
@@ -4248,11 +4248,11 @@ FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX
                 }
             }
         }
-        return TRUE;
+        return true;
     }
     ASSERT(m_bpp >= 24);
     if (m_bpp < 24) {
-        return FALSE;
+        return false;
     }
     if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ -4262,15 +4262,15 @@ FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
-            return FALSE;
+            return false;
         }
     }
     if(!IsCmykImage()) {
         color_p[3] = (uint8_t)src_alpha;
     }
     int Bpp = m_bpp / 8;
-    FX_BOOL bAlpha = HasAlpha();
-    FX_BOOL bArgb = GetFormat() == FXDIB_Argb ? TRUE : FALSE;
+    bool bAlpha = HasAlpha();
+    bool bArgb = GetFormat() == FXDIB_Argb ? true : false;
     if (src_alpha == 255) {
         for (int row = rect.top; row < rect.bottom; row ++) {
             uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
@@ -4291,7 +4291,7 @@ FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX
                 }
             }
         }
-        return TRUE;
+        return true;
     }
     for (int row = rect.top; row < rect.bottom; row ++) {
         uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left * Bpp;
@@ -4346,7 +4346,7 @@ FX_BOOL CFX_DIBitmap::CompositeRect(int left, int top, int width, int height, FX
             }
         }
     }
-    return TRUE;
+    return true;
 }
 CFX_BitmapComposer::CFX_BitmapComposer()
 {
@@ -4354,7 +4354,7 @@ CFX_BitmapComposer::CFX_BitmapComposer()
     m_pScanlineAlphaV = NULL;
     m_pClipScanV = NULL;
     m_pAddClipScan = NULL;
-    m_bRgbByteOrder = FALSE;
+    m_bRgbByteOrder = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_BitmapComposer::~CFX_BitmapComposer()
@@ -4373,8 +4373,8 @@ CFX_BitmapComposer::~CFX_BitmapComposer()
     }
 }
 void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest, const CFX_ClipRgn* pClipRgn, int bitmap_alpha,
-                                 FX_DWORD mask_color, FX_RECT& dest_rect, FX_BOOL bVertical,
-                                 FX_BOOL bFlipX, FX_BOOL bFlipY, FX_BOOL bRgbByteOrder,
+                                 FX_DWORD mask_color, FX_RECT& dest_rect, bool bVertical,
+                                 bool bFlipX, bool bFlipY, bool bRgbByteOrder,
                                  int alpha_flag, void* pIccTransform, int blend_type)
 {
     m_pBitmap = pDest;
@@ -4397,12 +4397,12 @@ void CFX_BitmapComposer::Compose(CFX_DIBitmap* pDest, const CFX_ClipRgn* pClipRg
     m_bRgbByteOrder = bRgbByteOrder;
     m_BlendType = blend_type;
 }
-FX_BOOL CFX_BitmapComposer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
+bool CFX_BitmapComposer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
 {
     m_SrcFormat = src_format;
     if (!m_Compositor.Init(m_pBitmap->GetFormat(), src_format, width, pSrcPalette, m_MaskColor, FXDIB_BLEND_NORMAL,
                            m_pClipMask != NULL || (m_BitmapAlpha < 255), m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform)) {
-        return FALSE;
+        return false;
     }
     if (m_bVertical) {
         m_pScanlineV = FX_Alloc(uint8_t, m_pBitmap->GetBPP() / 8 * width + 4);
@@ -4414,7 +4414,7 @@ FX_BOOL CFX_BitmapComposer::SetInfo(int width, int height, FXDIB_Format src_form
     if (m_BitmapAlpha < 255) {
         m_pAddClipScan = FX_Alloc(uint8_t, m_bVertical ? m_pBitmap->GetHeight() : m_pBitmap->GetWidth());
     }
-    return TRUE;
+    return true;
 }
 void CFX_BitmapComposer::DoCompose(uint8_t* dest_scan, const uint8_t* src_scan, int dest_width, const uint8_t* clip_scan,
                                    const uint8_t* src_extra_alpha, uint8_t* dst_extra_alpha)
diff --git a/core/src/fxge/dib/fx_dib_convert.cpp b/core/src/fxge/dib/fx_dib_convert.cpp
index d7860aee19..7e5a0341a2 100644
--- a/core/src/fxge/dib/fx_dib_convert.cpp
+++ b/core/src/fxge/dib/fx_dib_convert.cpp
@@ -103,7 +103,7 @@ public:
     CFX_Palette();
     ~CFX_Palette();
 public:
-    FX_BOOL      BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
+    bool      BuildPalette(const CFX_DIBSource* pBitmap, int dwPaletteType);
     FX_DWORD*    GetPalette() const
     {
         return m_pPalette;
@@ -227,10 +227,10 @@ CFX_Palette::~CFX_Palette()
     }
     m_lut = 0;
 }
-FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
+bool CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
 {
     if (pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pPalette != NULL) {
         FX_Free(m_pPalette);
@@ -277,9 +277,9 @@ FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type)
         win_mac_pal = (FX_DWORD*)g_dwMacPalette;
     }
     _Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     uint8_t set_gray, reset_gray;
@@ -296,9 +296,9 @@ FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int widt
             dest_scan ++;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     for (int row = 0; row < height; row ++) {
@@ -306,9 +306,9 @@ FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf, int dest_pitch, int widt
         const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
         FXSYS_memcpy(dest_scan, src_scan, width);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
@@ -359,9 +359,9 @@ FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width
             dest_scan ++;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     FX_DWORD* src_plt = pSrcBitmap->GetPalette();
@@ -402,9 +402,9 @@ FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf, int dest_pitch, int width
             *dest_scan++ = gray[*src_scan++];
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int Bpp = pSrcBitmap->GetBPP() / 8;
@@ -451,7 +451,7 @@ FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf, int dest_pitch, int wid
             }
         }
     }
-    return TRUE;
+    return true;
 }
 inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
@@ -476,7 +476,7 @@ inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf, int dest_pitch, int widt
         }
     }
 }
-FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 {
     _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top);
@@ -515,9 +515,9 @@ FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width,
             FXSYS_memcpy(dst_plt, src_plt, plt_size * 4);
         }
     }
-    return TRUE;
+    return true;
 }
-inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int dest_pitch, int width, int height,
+inline bool _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int dest_pitch, int width, int height,
         const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt)
 {
     int bpp = pSrcBitmap->GetBPP() / 8;
@@ -527,7 +527,7 @@ inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int des
     FX_DWORD* cLut = palette.GetColorLut();
     FX_DWORD* aLut = palette.GetAmountLut();
     if (cLut == NULL || aLut == NULL) {
-        return FALSE;
+        return false;
     }
     int lut = palette.Getlut();
     FX_DWORD* pPalette = palette.GetPalette();
@@ -571,12 +571,12 @@ inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf, int des
         }
     }
     FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD* dst_plt, void* pIccTransform)
 {
-    FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, dst_plt);
+    bool ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, dst_plt);
     if (ret && pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         for (int i = 0; i < 256; i++) {
@@ -588,7 +588,7 @@ FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf, int dest_pitch, int width,
     }
     return ret;
 }
-FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
@@ -611,9 +611,9 @@ FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf,
             dest_scan += comps;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top)
 {
     int comps = (dst_format & 0xff) / 8;
@@ -629,9 +629,9 @@ FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf,
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = (dst_format & 0xff) / 8;
@@ -676,9 +676,9 @@ FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, i
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = (dst_format & 0xff) / 8;
@@ -722,9 +722,9 @@ FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format, uint8_t* dest_buf, i
             dest_scan += comps - 2;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (pIccTransform) {
@@ -741,9 +741,9 @@ FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int wid
             FXSYS_memcpy(dest_scan, src_scan, width * 3);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     for (int row = 0; row < height; row ++) {
@@ -763,9 +763,9 @@ FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf, int dest_pitch, int wid
             pIccModule->TranslateScanline(pIccTransform, dest_scan, dest_scan, width);
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                  const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     int comps = pSrcBitmap->GetBPP() / 8;
@@ -793,9 +793,9 @@ FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, i
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf, int dest_pitch, int width, int height,
                                        const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (pIccTransform) {
@@ -821,9 +821,9 @@ FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf, int dest_pitch, int wi
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& d_pal, void* pIccTransform)
 {
     FXDIB_Format src_format = pSrcBitmap->GetFormat();
@@ -835,8 +835,8 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitc
         case FXDIB_1bppCmyk:
         case FXDIB_1bppMask:
         case FXDIB_1bppRgb:
-            ASSERT(FALSE);
-            return FALSE;
+            ASSERT(false);
+            return false;
         case FXDIB_8bppMask: {
                 if ((src_format & 0xff) == 1) {
                     if (pSrcBitmap->GetPalette()) {
@@ -853,7 +853,7 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitc
                 if ((src_format & 0xff) >= 24) {
                     return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_8bppRgb:
         case FXDIB_8bppRgba: {
@@ -867,7 +867,7 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitc
                 if ((src_format & 0xff) >= 24) {
                     return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, d_pal, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_Rgb:
         case FXDIB_Rgba: {
@@ -889,7 +889,7 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitc
                 if ((src_format & 0xff) == 32) {
                     return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         case FXDIB_Argb:
         case FXDIB_Rgb32: {
@@ -911,12 +911,12 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitc
                     }
                     return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top, pIccTransform);
                 }
-                return FALSE;
+                return false;
             }
         default:
-            return FALSE;
+            return false;
     }
-    return FALSE;
+    return false;
 }
 CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format, const FX_RECT* pClip, void* pIccTransform) const
 {
@@ -939,7 +939,7 @@ CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format, const FX_REC
         delete pClone;
         return NULL;
     }
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     CFX_DIBitmap* pSrcAlpha = NULL;
     if (m_AlphaFlag & 2) {
         pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
@@ -981,15 +981,15 @@ CFX_DIBitmap* CFX_DIBSource::CloneConvert(FXDIB_Format dest_format, const FX_REC
     }
     return pClone;
 }
-FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransform)
+bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransform)
 {
     FXDIB_Format src_format = GetFormat();
     if (dest_format == src_format && pIccTransform == NULL) {
-        return TRUE;
+        return true;
     }
     if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb && m_pPalette == NULL) {
         m_AlphaFlag = 1;
-        return TRUE;
+        return true;
     }
     if (dest_format == FXDIB_Argb && src_format == FXDIB_Rgb32 && pIccTransform == NULL) {
         m_AlphaFlag = 2;
@@ -1000,13 +1000,13 @@ FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransfor
                 scanline += 4;
             }
         }
-        return TRUE;
+        return true;
     }
     int dest_bpp = dest_format & 0xff;
     int dest_pitch = (dest_bpp * m_Width + 31) / 32 * 4;
     uint8_t* dest_buf = FX_TryAlloc(uint8_t, dest_pitch * m_Height + 4);
     if (dest_buf == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_DIBitmap* pAlphaMask = NULL;
     if (dest_format == FXDIB_Argb) {
@@ -1026,13 +1026,13 @@ FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransfor
             pAlphaMask = GetAlphaMask();
             if (pAlphaMask == NULL) {
                 FX_Free(dest_buf);
-                return FALSE;
+                return false;
             }
         } else {
             if (m_pAlphaMask == NULL) {
                 if (!BuildAlphaMask()) {
                     FX_Free(dest_buf);
-                    return FALSE;
+                    return false;
                 }
                 pAlphaMask = m_pAlphaMask;
                 m_pAlphaMask = NULL;
@@ -1041,7 +1041,7 @@ FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransfor
             }
         }
     }
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD* pal_8bpp = NULL;
     ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height, this, 0, 0, pal_8bpp, pIccTransform);
     if (!ret) {
@@ -1054,7 +1054,7 @@ FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransfor
         if (dest_buf) {
             FX_Free(dest_buf);
         }
-        return FALSE;
+        return false;
     }
     if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
         delete m_pAlphaMask;
@@ -1067,10 +1067,10 @@ FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format, void* pIccTransfor
     if (!m_bExtBuf) {
         FX_Free(m_pBuffer);
     }
-    m_bExtBuf = FALSE;
+    m_bExtBuf = false;
     m_pBuffer = dest_buf;
     m_bpp = (uint8_t)dest_format;
     m_AlphaFlag = (uint8_t)(dest_format >> 8);
     m_Pitch = dest_pitch;
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fxge/dib/fx_dib_engine.cpp b/core/src/fxge/dib/fx_dib_engine.cpp
index 7390c431d9..f143ac3ae2 100644
--- a/core/src/fxge/dib/fx_dib_engine.cpp
+++ b/core/src/fxge/dib/fx_dib_engine.cpp
@@ -217,7 +217,7 @@ CStretchEngine::CStretchEngine(IFX_ScanlineComposer* pDestBitmap, FXDIB_Format d
     m_SrcHeight = pSrcBitmap->GetHeight();
     m_SrcPitch = (m_SrcWidth * m_SrcBpp + 31) / 32 * 4;
     if ((flags & FXDIB_NOSMOOTH) == 0) {
-        FX_BOOL bInterpol = flags & FXDIB_INTERPOL || flags & FXDIB_BICUBIC_INTERPOL;
+        bool bInterpol = flags & FXDIB_INTERPOL || flags & FXDIB_BICUBIC_INTERPOL;
         if (!bInterpol && FXSYS_abs(dest_width) != 0 && FXSYS_abs(dest_height) < m_SrcWidth * m_SrcHeight * 8 / FXSYS_abs(dest_width)) {
             flags = FXDIB_INTERPOL;
         }
@@ -280,16 +280,16 @@ CStretchEngine::CStretchEngine(IFX_ScanlineComposer* pDestBitmap, FXDIB_Format d
         }
     }
 }
-FX_BOOL CStretchEngine::Continue(IFX_Pause* pPause)
+bool CStretchEngine::Continue(IFX_Pause* pPause)
 {
     while (m_State == 1) {
         if (ContinueStretchHorz(pPause)) {
-            return TRUE;
+            return true;
         }
         m_State = 2;
         StretchVert();
     }
-    return FALSE;
+    return false;
 }
 CStretchEngine::~CStretchEngine()
 {
@@ -306,46 +306,46 @@ CStretchEngine::~CStretchEngine()
         FX_Free(m_pDestMaskScanline);
     }
 }
-FX_BOOL CStretchEngine::StartStretchHorz()
+bool CStretchEngine::StartStretchHorz()
 {
     if (m_DestWidth == 0 || m_pDestScanline == NULL || m_SrcClip.Height() > (int)((1U << 29) / m_InterPitch) || m_SrcClip.Height() == 0) {
-        return FALSE;
+        return false;
     }
     m_pInterBuf = FX_TryAlloc(unsigned char, m_SrcClip.Height() * m_InterPitch);
     if (m_pInterBuf == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_pSource && m_bHasAlpha && m_pSource->m_pAlphaMask) {
         m_pExtraAlphaBuf = FX_Alloc2D(unsigned char, m_SrcClip.Height(), m_ExtraMaskPitch);
         FX_DWORD size = (m_DestClip.Width() * 8 + 31) / 32 * 4;
         m_pDestMaskScanline = FX_TryAlloc(unsigned char, size);
         if (!m_pDestMaskScanline) {
-            return FALSE;
+            return false;
         }
     }
     m_WeightTable.Calc(m_DestWidth, m_DestClip.left, m_DestClip.right, m_SrcWidth, m_SrcClip.left, m_SrcClip.right, m_Flags);
     if (m_WeightTable.m_pWeightTables == NULL) {
-        return FALSE;
+        return false;
     }
     m_CurRow = m_SrcClip.top;
     m_State = 1;
-    return TRUE;
+    return true;
 }
 #define FX_STRECH_PAUSE_ROWS	10
-FX_BOOL CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
+bool CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
 {
     if (!m_DestWidth) {
         return 0;
     }
     if (m_pSource->SkipToScanline(m_CurRow, pPause)) {
-        return TRUE;
+        return true;
     }
     int Bpp = m_DestBpp / 8;
     int rows_to_go = FX_STRECH_PAUSE_ROWS;
     for (; m_CurRow < m_SrcClip.bottom; m_CurRow ++) {
         if (rows_to_go == 0) {
             if (pPause && pPause->NeedToPauseNow()) {
-                return TRUE;
+                return true;
             }
             rows_to_go = FX_STRECH_PAUSE_ROWS;
         }
@@ -532,7 +532,7 @@ FX_BOOL CStretchEngine::ContinueStretchHorz(IFX_Pause* pPause)
         }
         rows_to_go --;
     }
-    return FALSE;
+    return false;
 }
 void CStretchEngine::StretchVert()
 {
@@ -697,7 +697,7 @@ FXDIB_Format _GetStretchedFormat(const CFX_DIBSource* pSrc)
     }
     return format;
 }
-FX_BOOL CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
+bool CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
                                   const CFX_DIBSource* pSource, int dest_width, int dest_height,
                                   const FX_RECT& rect, FX_DWORD flags)
 {
@@ -722,7 +722,7 @@ FX_BOOL CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
             pal[i] = ArgbEncode(a, r, g, b);
         }
         if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
-            return FALSE;
+            return false;
         }
     } else if (pSource->GetFormat() == FXDIB_1bppCmyk && pSource->GetPalette()) {
         FX_CMYK pal[256];
@@ -737,17 +737,17 @@ FX_BOOL CFX_ImageStretcher::Start(IFX_ScanlineComposer* pDest,
             pal[i] = CmykEncode(c, m, y, k);
         }
         if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, pal)) {
-            return FALSE;
+            return false;
         }
     } else if (!pDest->SetInfo(rect.Width(), rect.Height(), m_DestFormat, NULL)) {
-        return FALSE;
+        return false;
     }
     if (flags & FXDIB_DOWNSAMPLE) {
         return StartQuickStretch();
     }
     return StartStretch();
 }
-FX_BOOL CFX_ImageStretcher::Continue(IFX_Pause* pPause)
+bool CFX_ImageStretcher::Continue(IFX_Pause* pPause)
 {
     if (m_Flags & FXDIB_DOWNSAMPLE) {
         return ContinueQuickStretch(pPause);
@@ -755,39 +755,39 @@ FX_BOOL CFX_ImageStretcher::Continue(IFX_Pause* pPause)
     return ContinueStretch(pPause);
 }
 #define MAX_PROGRESSIVE_STRETCH_PIXELS	1000000
-FX_BOOL CFX_ImageStretcher::StartStretch()
+bool CFX_ImageStretcher::StartStretch()
 {
     m_pStretchEngine = new CStretchEngine(m_pDest, m_DestFormat, m_DestWidth, m_DestHeight, m_ClipRect, m_pSource, m_Flags);
     m_pStretchEngine->StartStretchHorz();
     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
         m_pStretchEngine->Continue(NULL);
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause)
+bool CFX_ImageStretcher::ContinueStretch(IFX_Pause* pPause)
 {
     if (m_pStretchEngine == NULL) {
-        return FALSE;
+        return false;
     }
     return m_pStretchEngine->Continue(pPause);
 }
-FX_BOOL CFX_ImageStretcher::StartQuickStretch()
+bool CFX_ImageStretcher::StartQuickStretch()
 {
-    m_bFlipX = FALSE;
-    m_bFlipY = FALSE;
+    m_bFlipX = false;
+    m_bFlipY = false;
     if (m_DestWidth < 0) {
-        m_bFlipX = TRUE;
+        m_bFlipX = true;
         m_DestWidth = -m_DestWidth;
     }
     if (m_DestHeight < 0) {
-        m_bFlipY = TRUE;
+        m_bFlipY = true;
         m_DestHeight = -m_DestHeight;
     }
     m_LineIndex = 0;
     FX_DWORD size = m_ClipRect.Width();
     if (size && m_DestBPP > (int)(INT_MAX / size)) {
-        return FALSE;
+        return false;
     }
     size *= m_DestBPP;
     m_pScanline = FX_Alloc(uint8_t, (size / 8 + 3) / 4 * 4);
@@ -796,14 +796,14 @@ FX_BOOL CFX_ImageStretcher::StartQuickStretch()
     }
     if (m_pSource->GetWidth() * m_pSource->GetHeight() < MAX_PROGRESSIVE_STRETCH_PIXELS) {
         ContinueQuickStretch(NULL);
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
+bool CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
 {
     if (m_pScanline == NULL) {
-        return FALSE;
+        return false;
     }
     int result_width = m_ClipRect.Width(), result_height = m_ClipRect.Height();
     int src_height = m_pSource->GetHeight();
@@ -823,7 +823,7 @@ FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
             src_y = 0;
         }
         if (m_pSource->SkipToScanline(src_y, pPause)) {
-            return TRUE;
+            return true;
         }
         m_pSource->DownSampleScanline(src_y, m_pScanline, m_DestBPP, m_DestWidth, m_bFlipX, m_ClipRect.left, result_width);
         if (m_pMaskScanline) {
@@ -831,5 +831,5 @@ FX_BOOL CFX_ImageStretcher::ContinueQuickStretch(IFX_Pause* pPause)
         }
         m_pDest->ComposeScanline(dest_y, m_pScanline, m_pMaskScanline);
     }
-    return FALSE;
+    return false;
 }
diff --git a/core/src/fxge/dib/fx_dib_main.cpp b/core/src/fxge/dib/fx_dib_main.cpp
index 8a864f10a1..efd886e2b7 100644
--- a/core/src/fxge/dib/fx_dib_main.cpp
+++ b/core/src/fxge/dib/fx_dib_main.cpp
@@ -9,7 +9,7 @@
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 #include <limits.h>
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& pal, void* pIccTransform);
 void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k)
 {
@@ -52,39 +52,39 @@ CFX_DIBSource::~CFX_DIBSource()
 }
 CFX_DIBitmap::CFX_DIBitmap()
 {
-    m_bExtBuf = FALSE;
+    m_bExtBuf = false;
     m_pBuffer = NULL;
     m_pPalette = NULL;
 }
 #define _MAX_OOM_LIMIT_	12000000
-FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer, int pitch)
+bool CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer, int pitch)
 {
     m_pBuffer = NULL;
     m_bpp = (uint8_t)format;
     m_AlphaFlag = (uint8_t)(format >> 8);
     m_Width = m_Height = m_Pitch = 0;
     if (width <= 0 || height <= 0 || pitch < 0) {
-        return FALSE;
+        return false;
     }
     if ((INT_MAX - 31) / width < (format & 0xff)) {
-        return FALSE;
+        return false;
     }
     if (!pitch) {
         pitch = (width * (format & 0xff) + 31) / 32 * 4;
     }
     if ((1 << 30) / pitch < height) {
-        return FALSE;
+        return false;
     }
     if (pBuffer) {
         m_pBuffer = pBuffer;
-        m_bExtBuf = TRUE;
+        m_bExtBuf = true;
     } else {
         int size = pitch * height + 4;
         int oomlimit = _MAX_OOM_LIMIT_;
         if (oomlimit >= 0 && size >= oomlimit) {
             m_pBuffer = FX_TryAlloc(uint8_t, size);
             if (m_pBuffer == NULL) {
-                return FALSE;
+                return false;
             }
         } else {
             m_pBuffer = FX_Alloc(uint8_t, size);
@@ -94,33 +94,33 @@ FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, uint8_t
     m_Height = height;
     m_Pitch = pitch;
     if (HasAlpha() && format != FXDIB_Argb) {
-        FX_BOOL ret = TRUE;
+        bool ret = true;
         ret = BuildAlphaMask();
         if (!ret) {
             if (!m_bExtBuf && m_pBuffer) {
                 FX_Free(m_pBuffer);
                 m_pBuffer = NULL;
                 m_Width = m_Height = m_Pitch = 0;
-                return FALSE;
+                return false;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
+bool CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
 {
     if (m_pBuffer) {
-        return FALSE;
+        return false;
     }
     if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
-        return FALSE;
+        return false;
     }
     CopyPalette(pSrc->GetPalette());
     CopyAlphaMask(pSrc->m_pAlphaMask);
     for (int row = 0; row < pSrc->GetHeight(); row ++) {
         FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
     }
-    return TRUE;
+    return true;
 }
 CFX_DIBitmap::~CFX_DIBitmap()
 {
@@ -218,19 +218,19 @@ void CFX_DIBSource::BuildPalette()
         }
     }
 }
-FX_BOOL CFX_DIBSource::BuildAlphaMask()
+bool CFX_DIBSource::BuildAlphaMask()
 {
     if (m_pAlphaMask) {
-        return TRUE;
+        return true;
     }
     m_pAlphaMask = new CFX_DIBitmap;
     if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete m_pAlphaMask;
         m_pAlphaMask = NULL;
-        return FALSE;
+        return false;
     }
     FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-    return TRUE;
+    return true;
 }
 FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const
 {
@@ -367,15 +367,15 @@ void CFX_DIBSource::GetOverlapRect(int& dest_left, int& dest_top, int& width, in
     width = dest_rect.right - dest_rect.left;
     height = dest_rect.bottom - dest_rect.top;
 }
-FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     FXDIB_Format dest_format = GetFormat();
     FXDIB_Format src_format = pSrcBitmap->GetFormat();
@@ -402,7 +402,7 @@ FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int
         }
     } else {
         if (m_pPalette) {
-            return FALSE;
+            return false;
         }
         if (m_bpp == 8) {
             dest_format = FXDIB_8bppMask;
@@ -410,25 +410,25 @@ FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int
         uint8_t* dest_buf = m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
         FX_DWORD* d_plt = NULL;
         if(!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
                                    const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(HasAlpha() && (m_bpp >= 24));
     ASSERT(pMask->IsAlphaMask());
     if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, NULL);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     int src_bpp = pMask->GetBPP();
     int alpha;
@@ -449,7 +449,7 @@ FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int h
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
-            return FALSE;
+            return false;
         }
     }
     if(!IsCmykImage()) {
@@ -507,7 +507,7 @@ FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int h
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size)
 {
@@ -570,21 +570,21 @@ CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const
     }
     return pMask;
 }
-FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
+bool CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
 {
     if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
-        return FALSE;
+        return false;
     }
     if (pAlphaMask) {
         FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
         if (pClip) {
             rect.Intersect(*pClip);
             if (rect.IsEmpty() || rect.Width() != m_Width || rect.Height() != m_Height) {
-                return FALSE;
+                return false;
             }
         } else {
             if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
-                return FALSE;
+                return false;
             }
         }
         for (int row = 0; row < m_Height; row ++)
@@ -593,25 +593,25 @@ FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_R
     } else {
         m_pAlphaMask->Clear(0xff000000);
     }
-    return TRUE;
+    return true;
 }
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
     CFX_DIBitmap* pDst = this;
     int destOffset, srcOffset;
     if (srcChannel == FXDIB_Alpha) {
         if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (pSrcBitmap->GetBPP() == 1) {
             pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
             if (pSrcClone == NULL) {
-                return FALSE;
+                return false;
             }
         }
         if(pSrcBitmap->GetFormat() == FXDIB_Argb) {
@@ -621,7 +621,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
         }
     } else {
         if (pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (pSrcBitmap->GetBPP() < 24) {
             if (pSrcBitmap->IsCmykImage()) {
@@ -630,7 +630,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                 pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
             }
             if (pSrcClone == NULL) {
-                return FALSE;
+                return false;
             }
         }
         srcOffset = g_ChannelOffset[srcChannel];
@@ -641,7 +641,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             destOffset = 0;
         } else {
@@ -650,7 +650,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             if (GetFormat() == FXDIB_Argb) {
                 destOffset = 3;
@@ -661,7 +661,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
             if (pSrcClone != pSrcBitmap) {
                 delete pSrcClone;
             }
-            return FALSE;
+            return false;
         }
         if (GetBPP() < 24) {
             if (HasAlpha()) {
@@ -669,7 +669,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
             } else
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
@@ -680,7 +680,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
         }
         destOffset = g_ChannelOffset[destChannel];
@@ -694,7 +694,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
             }
         }
@@ -710,7 +710,7 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
             delete pSrcClone;
         }
         if (pSrcMatched == NULL) {
-            return FALSE;
+            return false;
         }
         pSrcClone = pSrcMatched;
     }
@@ -732,24 +732,24 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource
     if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
         delete pSrcClone;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     int destOffset;
     if (destChannel == FXDIB_Alpha) {
         if (IsAlphaMask()) {
             if(!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
+                return false;
             }
             destOffset = 0;
         } else {
             destOffset = 0;
             if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                return FALSE;
+                return false;
             }
             if (GetFormat() == FXDIB_Argb) {
                 destOffset = 3;
@@ -757,21 +757,21 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
         }
     } else {
         if (IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (GetBPP() < 24) {
             if (HasAlpha()) {
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                    return FALSE;
+                    return false;
                 }
             } else
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-                    return FALSE;
+                    return false;
                 }
 #else
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-                    return FALSE;
+                    return false;
                 }
 #endif
         }
@@ -780,11 +780,11 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
     int Bpp = GetBPP() / 8;
     if (Bpp == 1) {
         FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
-        return TRUE;
+        return true;
     }
     if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
         FXSYS_memset(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-        return TRUE;
+        return true;
     }
     for (int row = 0; row < m_Height; row ++) {
         uint8_t* scan_line = m_pBuffer + row * m_Pitch + destOffset;
@@ -793,16 +793,16 @@ FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
             scan_line += Bpp;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
+bool CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(pSrcBitmap->IsAlphaMask());
     if (!pSrcBitmap->IsAlphaMask()) {
-        return FALSE;
+        return false;
     }
     if (!IsAlphaMask() && !HasAlpha()) {
         return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
@@ -812,7 +812,7 @@ FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
         pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
         ASSERT(pSrcClone != NULL);
         if (pSrcClone == NULL) {
-            return FALSE;
+            return false;
         }
     }
     if (IsAlphaMask()) {
@@ -820,7 +820,7 @@ FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
             if (pSrcClone != pSrcBitmap) {
                 delete pSrcClone;
             }
-            return FALSE;
+            return false;
         }
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* dest_scan = m_pBuffer + m_Pitch * row;
@@ -844,7 +844,7 @@ FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             for (int row = 0; row < m_Height; row ++) {
                 uint8_t* dest_scan = m_pBuffer + m_Pitch * row + 3;
@@ -861,17 +861,17 @@ FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
     if (pSrcClone != pSrcBitmap) {
         delete pSrcClone;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
+bool CFX_DIBitmap::GetGrayData(void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     switch (GetFormat()) {
         case FXDIB_1bppRgb: {
                 if (m_pPalette == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 uint8_t gray[2];
                 for (int i = 0; i < 2; i ++) {
@@ -883,7 +883,7 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 FXSYS_memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
                 for (int row = 0; row < m_Height; row ++) {
@@ -902,7 +902,7 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
             }
         case FXDIB_8bppRgb: {
                 if (m_pPalette == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 uint8_t gray[256];
                 for (int i = 0; i < 256; i ++) {
@@ -914,7 +914,7 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
@@ -931,7 +931,7 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
@@ -949,7 +949,7 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
@@ -964,19 +964,19 @@ FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
                 break;
             }
         default:
-            return FALSE;
+            return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha)
+bool CFX_DIBitmap::MultiplyAlpha(int alpha)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     switch (GetFormat()) {
         case FXDIB_1bppMask:
             if (!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
+                return false;
             }
             MultiplyAlpha(alpha);
             break;
@@ -1004,18 +1004,18 @@ FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha)
                 m_pAlphaMask->MultiplyAlpha(alpha);
             } else if (IsCmykImage()) {
                 if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
-                    return FALSE;
+                    return false;
                 }
                 m_pAlphaMask->MultiplyAlpha(alpha);
             } else {
                 if (!ConvertFormat(FXDIB_Argb)) {
-                    return FALSE;
+                    return false;
                 }
                 MultiplyAlpha(alpha);
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const
 {
@@ -1122,7 +1122,7 @@ void CFX_DIBitmap::SetPixel(int x, int y, FX_DWORD color)
     }
 }
 void CFX_DIBitmap::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-                                      int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
+                                      int dest_width, bool bFlipX, int clip_left, int clip_width) const
 {
     if (m_pBuffer == NULL) {
         return;
@@ -1179,15 +1179,15 @@ void CFX_DIBitmap::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp
         }
     }
 }
-FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
+bool CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
 {
     ASSERT(!IsAlphaMask());
     if (m_pBuffer == NULL || IsAlphaMask()) {
-        return FALSE;
+        return false;
     }
     int fc, fm, fy, fk, bc, bm, by, bk;
     int fr, fg, fb, br, bg, bb;
-    FX_BOOL isCmykImage = IsCmykImage();
+    bool isCmykImage = IsCmykImage();
     if (isCmykImage) {
         fc = FXSYS_GetCValue(forecolor);
         fm = FXSYS_GetMValue(forecolor);
@@ -1208,10 +1208,10 @@ FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
     if (m_bpp <= 8) {
         if (isCmykImage) {
             if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
-                return TRUE;
+                return true;
             }
         } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
-            return TRUE;
+            return true;
         }
         if (m_pPalette == NULL) {
             BuildPalette();
@@ -1232,7 +1232,7 @@ FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
                 m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255, bg + (fg - bg) * gray / 255,
                                             bb + (fb - bb) * gray / 255);
             }
-        return TRUE;
+        return true;
     }
     if (isCmykImage) {
         if (forecolor == 0xff && backcolor == 0x00) {
@@ -1248,7 +1248,7 @@ FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
                     *scanline ++ = 255 - FXRGB2GRAY(r, g, b);
                 }
             }
-            return TRUE;
+            return true;
         }
     } else if (forecolor == 0 && backcolor == 0xffffff) {
         for (int row = 0; row < m_Height; row ++) {
@@ -1262,7 +1262,7 @@ FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
                 scanline += gap;
             }
         }
-        return TRUE;
+        return true;
     }
     if (isCmykImage) {
         for (int row = 0; row < m_Height; row ++) {
@@ -1291,18 +1291,18 @@ FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
+bool CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
-        return FALSE;
+        return false;
     }
     if (m_Width < 4 && m_Height < 4) {
-        return FALSE;
+        return false;
     }
     FX_RECT rect(0, 0, m_Width, m_Height);
     if (pRect) {
@@ -1374,9 +1374,9 @@ FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_
             }
         }
     }
-    return TRUE;
+    return true;
 }
-CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const
+CFX_DIBitmap* CFX_DIBSource::FlipImage(bool bXFlip, bool bYFlip) const
 {
     CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
     if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
@@ -1480,7 +1480,7 @@ CFX_FilteredDIB::~CFX_FilteredDIB()
         FX_Free(m_pScanline);
     }
 }
-void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
+void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, bool bAutoDropSrc)
 {
     m_pSrc = pSrc;
     m_bAutoDropSrc = bAutoDropSrc;
@@ -1499,7 +1499,7 @@ const uint8_t* CFX_FilteredDIB::GetScanline(int line) const
     return m_pScanline;
 }
 void CFX_FilteredDIB::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-        int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
+        int dest_width, bool bFlipX, int clip_left, int clip_width) const
 {
     m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
     TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
@@ -1508,18 +1508,18 @@ CFX_ImageRenderer::CFX_ImageRenderer()
 {
     m_Status = 0;
     m_pTransformer = NULL;
-    m_bRgbByteOrder = FALSE;
+    m_bRgbByteOrder = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ImageRenderer::~CFX_ImageRenderer()
 {
     delete m_pTransformer;
 }
-extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY);
-FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
+extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, bool bFlipX, bool bFlipY);
+bool CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
                                  const CFX_DIBSource* pSource, int bitmap_alpha,
                                  FX_DWORD mask_color, const CFX_AffineMatrix* pMatrix,
-                                 FX_DWORD dib_flags, FX_BOOL bRgbByteOrder,
+                                 FX_DWORD dib_flags, bool bRgbByteOrder,
                                  int alpha_flag, void* pIccTransform, int blend_type)
 {
     m_Matrix = *pMatrix;
@@ -1528,7 +1528,7 @@ FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClip
     m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(), pDevice->GetHeight());
     m_ClipBox.Intersect(image_rect);
     if (m_ClipBox.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
@@ -1540,7 +1540,7 @@ FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClip
     m_pIccTransform = pIccTransform;
     m_bRgbByteOrder = bRgbByteOrder;
     m_BlendType = blend_type;
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
             (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0) ) {
         if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 && FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
@@ -1550,18 +1550,18 @@ FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClip
             FX_RECT bitmap_clip = m_ClipBox;
             bitmap_clip.Offset(-image_rect.left, -image_rect.top);
             bitmap_clip = _FXDIB_SwapClipBox(bitmap_clip, dest_width, dest_height, m_Matrix.c > 0, m_Matrix.b < 0);
-            m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, TRUE,
+            m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, true,
                                m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
             if (!m_Stretcher.Start(&m_Composer, pSource, dest_height, dest_width, bitmap_clip, dib_flags)) {
-                return FALSE;
+                return false;
             }
             m_Status = 1;
-            return TRUE;
+            return true;
         }
         m_Status = 2;
         m_pTransformer = new CFX_ImageTransformer;
         m_pTransformer->Start(pSource, &m_Matrix, dib_flags, &m_ClipBox);
-        return TRUE;
+        return true;
     }
     int dest_width = image_rect.Width();
     if (m_Matrix.a < 0) {
@@ -1572,32 +1572,32 @@ FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClip
         dest_height = -dest_height;
     }
     if (dest_width == 0 || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     FX_RECT bitmap_clip = m_ClipBox;
     bitmap_clip.Offset(-image_rect.left, -image_rect.top);
     m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color,
-                       m_ClipBox, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
+                       m_ClipBox, false, false, false, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
     m_Status = 1;
     ret = m_Stretcher.Start(&m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
     return ret;
 }
-FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause)
+bool CFX_ImageRenderer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
         return m_Stretcher.Continue(pPause);
     }
     if (m_Status == 2) {
         if (m_pTransformer->Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         if (pBitmap->GetBuffer() == NULL) {
             delete pBitmap;
-            return FALSE;
+            return false;
         }
         if (pBitmap->IsAlphaMask()) {
             if (m_BitmapAlpha != 255) {
@@ -1618,9 +1618,9 @@ FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause)
                                        pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, 0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_pIccTransform);
         }
         delete pBitmap;
-        return FALSE;
+        return false;
     }
-    return FALSE;
+    return false;
 }
 CFX_BitmapStorer::CFX_BitmapStorer()
 {
@@ -1653,16 +1653,16 @@ void CFX_BitmapStorer::ComposeScanline(int line, const uint8_t* scanline, const
         FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
     }
 }
-FX_BOOL CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
+bool CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
 {
     m_pBitmap = new CFX_DIBitmap;
     if (!m_pBitmap->Create(width, height, src_format)) {
         delete m_pBitmap;
         m_pBitmap = NULL;
-        return FALSE;
+        return false;
     }
     if (pSrcPalette) {
         m_pBitmap->CopyPalette(pSrcPalette);
     }
-    return TRUE;
+    return true;
 }
diff --git a/core/src/fxge/dib/fx_dib_transform.cpp b/core/src/fxge/dib/fx_dib_transform.cpp
index e34e715bf2..01bc167ede 100644
--- a/core/src/fxge/dib/fx_dib_transform.cpp
+++ b/core/src/fxge/dib/fx_dib_transform.cpp
@@ -54,7 +54,7 @@ public:
         y1 /= base;
     }
 };
-CFX_DIBitmap* CFX_DIBSource::SwapXY(FX_BOOL bXFlip, FX_BOOL bYFlip, const FX_RECT* pDestClip) const
+CFX_DIBitmap* CFX_DIBSource::SwapXY(bool bXFlip, bool bYFlip, const FX_RECT* pDestClip) const
 {
     FX_RECT dest_clip(0, 0, m_Height, m_Width);
     if (pDestClip) {
@@ -148,7 +148,7 @@ CFX_DIBitmap* CFX_DIBSource::SwapXY(FX_BOOL bXFlip, FX_BOOL bYFlip, const FX_REC
     return pTransBitmap;
 }
 #define FIX16_005 0.05f
-FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY)
+FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, bool bFlipX, bool bFlipY)
 {
     FX_RECT rect;
     if (bFlipY) {
@@ -206,7 +206,7 @@ CFX_ImageTransformer::CFX_ImageTransformer()
 CFX_ImageTransformer::~CFX_ImageTransformer()
 {
 }
-FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix, int flags, const FX_RECT* pDestClip)
+bool CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pDestMatrix, int flags, const FX_RECT* pDestClip)
 {
     m_pMatrix = (CFX_AffineMatrix*)pDestMatrix;
     CFX_FloatRect unit_rect = pDestMatrix->GetUnitRect();
@@ -216,7 +216,7 @@ FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineM
         result_clip.Intersect(*pDestClip);
     }
     if (result_clip.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     m_ResultLeft = result_clip.left;
     m_ResultTop = result_clip.top;
@@ -232,7 +232,7 @@ FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineM
         result_clip = _FXDIB_SwapClipBox(result_clip, dest_width, dest_height, pDestMatrix->c > 0, pDestMatrix->b < 0);
         m_Stretcher.Start(&m_Storer, pSrc, dest_height, dest_width, result_clip, flags);
         m_Status = 1;
-        return TRUE;
+        return true;
     }
     if (FXSYS_fabs(pDestMatrix->b) < FIX16_005 && FXSYS_fabs(pDestMatrix->c) < FIX16_005) {
         int dest_width = pDestMatrix->a > 0 ? (int)FXSYS_ceil(pDestMatrix->a) : (int)FXSYS_floor(pDestMatrix->a);
@@ -240,7 +240,7 @@ FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineM
         result_clip.Offset(-result_rect.left, -result_rect.top);
         m_Stretcher.Start(&m_Storer, pSrc, dest_width, dest_height, result_clip, flags);
         m_Status = 2;
-        return TRUE;
+        return true;
     }
     int stretch_width = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->a, pDestMatrix->b));
     int stretch_height = (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->c, pDestMatrix->d));
@@ -254,7 +254,7 @@ FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc, const CFX_AffineM
     m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);
     m_Stretcher.Start(&m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags);
     m_Status = 3;
-    return TRUE;
+    return true;
 }
 uint8_t _bilinear_interpol(const uint8_t* buf, int row_offset_l, int row_offset_r,
                            int src_col_l, int src_col_r, int res_x, int res_y,
@@ -335,30 +335,30 @@ FXDIB_Format _GetTransformedFormat(const CFX_DIBSource* pDrc)
     }
     return format;
 }
-FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)
+bool CFX_ImageTransformer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
         if (m_Stretcher.Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         if (m_Storer.GetBitmap()) {
             m_Storer.Replace(m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));
         }
-        return FALSE;
+        return false;
     }
     if (m_Status == 2) {
         return m_Stretcher.Continue(pPause);
     }
     if (m_Status != 3) {
-        return FALSE;
+        return false;
     }
     if (m_Stretcher.Continue(pPause)) {
-        return TRUE;
+        return true;
     }
     int stretch_width = m_StretchClip.Width();
     int stretch_height = m_StretchClip.Height();
     if (m_Storer.GetBitmap() == NULL) {
-        return FALSE;
+        return false;
     }
     const uint8_t* stretch_buf = m_Storer.GetBitmap()->GetBuffer();
     const uint8_t* stretch_buf_mask = NULL;
@@ -370,7 +370,7 @@ FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)
     FXDIB_Format transformF = _GetTransformedFormat(m_Stretcher.m_pSource);
     if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF)) {
         delete pTransformed;
-        return FALSE;
+        return false;
     }
     pTransformed->Clear(0);
     if (pTransformed->m_pAlphaMask) {
@@ -641,7 +641,7 @@ FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)
                 }
             }
         } else {
-            FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
+            bool bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
             int destBpp = pTransformed->GetBPP() / 8;
             if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
                 CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
@@ -786,5 +786,5 @@ FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause)
         }
     }
     m_Storer.Replace(pTransformed);
-    return FALSE;
+    return false;
 }
diff --git a/core/src/fxge/ge/fx_ge_device.cpp b/core/src/fxge/ge/fx_ge_device.cpp
index 0baa99cdc7..ecdd1b0183 100644
--- a/core/src/fxge/ge/fx_ge_device.cpp
+++ b/core/src/fxge/ge/fx_ge_device.cpp
@@ -35,7 +35,7 @@ void CFX_RenderDevice::InitDeviceInfo()
         m_ClipBox.bottom = m_Height;
     }
 }
-FX_BOOL CFX_RenderDevice::StartRendering()
+bool CFX_RenderDevice::StartRendering()
 {
     return m_pDeviceDriver->StartRendering();
 }
@@ -47,7 +47,7 @@ void CFX_RenderDevice::SaveState()
 {
     m_pDeviceDriver->SaveState();
 }
-void CFX_RenderDevice::RestoreState(FX_BOOL bKeepSaved)
+void CFX_RenderDevice::RestoreState(bool bKeepSaved)
 {
     m_pDeviceDriver->RestoreState(bKeepSaved);
     UpdateClipBox();
@@ -60,7 +60,7 @@ CFX_Matrix CFX_RenderDevice::GetCTM() const
 {
     return m_pDeviceDriver->GetCTM();
 }
-FX_BOOL CFX_RenderDevice::CreateCompatibleBitmap(CFX_DIBitmap* pDIB, int width, int height) const
+bool CFX_RenderDevice::CreateCompatibleBitmap(CFX_DIBitmap* pDIB, int width, int height) const
 {
     if (m_RenderCaps & FXRC_CMYK_OUTPUT) {
         return pDIB->Create(width, height, m_RenderCaps & FXRC_ALPHA_OUTPUT ? FXDIB_Cmyka : FXDIB_Cmyk);
@@ -74,37 +74,37 @@ FX_BOOL CFX_RenderDevice::CreateCompatibleBitmap(CFX_DIBitmap* pDIB, int width,
     return pDIB->Create(width, height, m_RenderCaps & FXRC_ALPHA_OUTPUT ? FXDIB_Argb : FXDIB_Rgb);
 #endif
 }
-FX_BOOL CFX_RenderDevice::SetClip_PathFill(const CFX_PathData* pPathData,
+bool CFX_RenderDevice::SetClip_PathFill(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pObject2Device,
         int fill_mode
                                           )
 {
     if (!m_pDeviceDriver->SetClip_PathFill(pPathData, pObject2Device, fill_mode)) {
-        return FALSE;
+        return false;
     }
     UpdateClipBox();
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_RenderDevice::SetClip_PathStroke(const CFX_PathData* pPathData,
+bool CFX_RenderDevice::SetClip_PathStroke(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pObject2Device,
         const CFX_GraphStateData* pGraphState
                                             )
 {
     if (!m_pDeviceDriver->SetClip_PathStroke(pPathData, pObject2Device, pGraphState)) {
-        return FALSE;
+        return false;
     }
     UpdateClipBox();
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_RenderDevice::SetClip_Rect(const FX_RECT* pRect)
+bool CFX_RenderDevice::SetClip_Rect(const FX_RECT* pRect)
 {
     CFX_PathData path;
     path.AppendRect((FX_FLOAT)(pRect->left), (FX_FLOAT)(pRect->bottom), (FX_FLOAT)(pRect->right), (FX_FLOAT)(pRect->top));
     if (!SetClip_PathFill(&path, NULL, FXFILL_WINDING)) {
-        return FALSE;
+        return false;
     }
     UpdateClipBox();
-    return TRUE;
+    return true;
 }
 void CFX_RenderDevice::UpdateClipBox()
 {
@@ -116,7 +116,7 @@ void CFX_RenderDevice::UpdateClipBox()
     m_ClipBox.right = m_Width;
     m_ClipBox.bottom = m_Height;
 }
-FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
+bool CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_AffineMatrix* pObject2Device,
                                    const CFX_GraphStateData* pGraphState,
                                    FX_DWORD fill_color, FX_DWORD stroke_color, int fill_mode,
@@ -149,7 +149,7 @@ FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
             y2 = pPoints[1].m_PointY;
         }
         DrawCosmeticLine(x1, y1, x2, y2, fill_color, fill_mode, alpha_flag, pIccTransform, blend_type);
-        return TRUE;
+        return true;
     }
     if ((pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) && stroke_alpha == 0) {
         CFX_FloatRect rect_f;
@@ -184,13 +184,13 @@ FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
                 }
             }
             if (FillRect(&rect_i, fill_color, alpha_flag, pIccTransform, blend_type)) {
-                return TRUE;
+                return true;
             }
         }
     }
     if((fill_mode & 3) && stroke_alpha == 0 && !(fill_mode & FX_FILL_STROKE) && !(fill_mode & FX_FILL_TEXT_MODE)) {
         CFX_PathData newPath;
-        FX_BOOL bThin = FALSE;
+        bool bThin = false;
         if (pPathData->GetZeroAreaPath(newPath, (CFX_Matrix*)pObject2Device, bThin, m_pDeviceDriver->GetDriverType())) {
             CFX_GraphStateData graphState;
             graphState.m_LineWidth = 0.0f;
@@ -215,7 +215,7 @@ FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
     }
     if ((fill_mode & 3) && fill_alpha && stroke_alpha < 0xff && (fill_mode & FX_FILL_STROKE)) {
         if (!(m_RenderCaps & FXRC_GET_BITS)) {
-            return FALSE;
+            return false;
         }
         CFX_FloatRect bbox;
         if (pGraphState) {
@@ -232,19 +232,19 @@ FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
         FX_RECT rect = bbox.GetOutterRect();
         CFX_DIBitmap bitmap, Backdrop;
         if (!CreateCompatibleBitmap(&bitmap, FXSYS_round(rect.Width() * fScaleX), FXSYS_round(rect.Height() * fScaleY))) {
-            return FALSE;
+            return false;
         }
         if (bitmap.HasAlpha()) {
             bitmap.Clear(0);
             Backdrop.Copy(&bitmap);
         } else {
             if (!m_pDeviceDriver->GetDIBits(&bitmap, rect.left, rect.top, NULL)) {
-                return FALSE;
+                return false;
             }
             Backdrop.Copy(&bitmap);
         }
         CFX_FxgeDevice bitmap_device;
-        bitmap_device.Attach(&bitmap, 0, FALSE, &Backdrop, TRUE);
+        bitmap_device.Attach(&bitmap, 0, false, &Backdrop, true);
         CFX_AffineMatrix matrix;
         if (pObject2Device) {
             matrix = *pObject2Device;
@@ -252,51 +252,51 @@ FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
         matrix.TranslateI(-rect.left, -rect.top);
         matrix.Concat(fScaleX, 0, 0, fScaleY, 0, 0);
         if (!bitmap_device.GetDeviceDriver()->DrawPath(pPathData, &matrix, pGraphState, fill_color, stroke_color, fill_mode, alpha_flag, pIccTransform, blend_type)) {
-            return FALSE;
+            return false;
         }
         FX_RECT src_rect(0, 0, FXSYS_round(rect.Width() * fScaleX), FXSYS_round(rect.Height() * fScaleY));
         return m_pDeviceDriver->SetDIBits(&bitmap, 0, &src_rect, rect.left, rect.top, FXDIB_BLEND_NORMAL);
     }
     return m_pDeviceDriver->DrawPath(pPathData, pObject2Device, pGraphState, fill_color, stroke_color, fill_mode, alpha_flag, pIccTransform, blend_type);
 }
-FX_BOOL CFX_RenderDevice::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
+bool CFX_RenderDevice::SetPixel(int x, int y, FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (m_pDeviceDriver->SetPixel(x, y, color, alpha_flag, pIccTransform)) {
-        return TRUE;
+        return true;
     }
     FX_RECT rect(x, y, x + 1, y + 1);
     return FillRect(&rect, color, alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_RenderDevice::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
+bool CFX_RenderDevice::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (m_pDeviceDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform, blend_type)) {
-        return TRUE;
+        return true;
     }
     if (!(m_RenderCaps & FXRC_GET_BITS)) {
-        return FALSE;
+        return false;
     }
     CFX_DIBitmap bitmap;
     if (!CreateCompatibleBitmap(&bitmap, pRect->Width(), pRect->Height())) {
-        return FALSE;
+        return false;
     }
     if (!m_pDeviceDriver->GetDIBits(&bitmap, pRect->left, pRect->top)) {
-        return FALSE;
+        return false;
     }
     if (!bitmap.CompositeRect(0, 0, pRect->Width(), pRect->Height(), fill_color, alpha_flag, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     FX_RECT src_rect(0, 0, pRect->Width(), pRect->Height());
     m_pDeviceDriver->SetDIBits(&bitmap, 0, &src_rect, pRect->left, pRect->top, FXDIB_BLEND_NORMAL);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_RenderDevice::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+bool CFX_RenderDevice::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
         int fill_mode, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (((m_RenderCaps & FXRC_ALPHA_PATH) &&
             (FXGETFLAG_COLORTYPE(alpha_flag) && FXGETFLAG_ALPHA_FILL(alpha_flag) == 0xff)) ||
             color >= 0xff000000)
         if (m_pDeviceDriver->DrawCosmeticLine(x1, y1, x2, y2, color, alpha_flag, pIccTransform, blend_type)) {
-            return TRUE;
+            return true;
         }
     CFX_GraphStateData graph_state;
     CFX_PathData path;
@@ -305,10 +305,10 @@ FX_BOOL CFX_RenderDevice::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2
     path.SetPoint(1, x2, y2, FXPT_LINETO);
     return m_pDeviceDriver->DrawPath(&path, NULL, &graph_state, 0, color, fill_mode, alpha_flag, pIccTransform, blend_type);
 }
-FX_BOOL CFX_RenderDevice::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform)
+bool CFX_RenderDevice::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform)
 {
     if (!(m_RenderCaps & FXRC_GET_BITS)) {
-        return FALSE;
+        return false;
     }
     return m_pDeviceDriver->GetDIBits(pBitmap, left, top, pIccTransform);
 }
@@ -316,7 +316,7 @@ CFX_DIBitmap* CFX_RenderDevice::GetBackDrop()
 {
     return m_pDeviceDriver->GetBackDrop();
 }
-FX_BOOL CFX_RenderDevice::SetDIBits(const CFX_DIBSource* pBitmap, int left, int top, int blend_mode,
+bool CFX_RenderDevice::SetDIBits(const CFX_DIBSource* pBitmap, int left, int top, int blend_mode,
                                     void* pIccTransform)
 {
     ASSERT(!pBitmap->IsAlphaMask());
@@ -326,7 +326,7 @@ FX_BOOL CFX_RenderDevice::SetDIBits(const CFX_DIBSource* pBitmap, int left, int
     FX_RECT dest_rect(left, top, FXSYS_round(left + pBitmap->GetWidth() / fScaleX), FXSYS_round(top + pBitmap->GetHeight() / fScaleY));
     dest_rect.Intersect(m_ClipBox);
     if (dest_rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     FX_RECT src_rect(dest_rect.left - left, dest_rect.top - top,
                      dest_rect.left - left + dest_rect.Width(), dest_rect.top - top + dest_rect.Height());
@@ -337,29 +337,29 @@ FX_BOOL CFX_RenderDevice::SetDIBits(const CFX_DIBSource* pBitmap, int left, int
     if ((blend_mode != FXDIB_BLEND_NORMAL && !(m_RenderCaps & FXRC_BLEND_MODE)) ||
             (pBitmap->HasAlpha() && !(m_RenderCaps & FXRC_ALPHA_IMAGE))) {
         if (!(m_RenderCaps & FXRC_GET_BITS)) {
-            return FALSE;
+            return false;
         }
         int bg_pixel_width = FXSYS_round(dest_rect.Width() * fScaleX);
         int bg_pixel_height = FXSYS_round(dest_rect.Height() * fScaleY);
         CFX_DIBitmap background;
         if (!background.Create(bg_pixel_width, bg_pixel_height,
                                (m_RenderCaps & FXRC_CMYK_OUTPUT) ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-            return FALSE;
+            return false;
         }
         if (!m_pDeviceDriver->GetDIBits(&background, dest_rect.left, dest_rect.top)) {
-            return FALSE;
+            return false;
         }
         if (!background.CompositeBitmap(0, 0, bg_pixel_width, bg_pixel_height,
                                         pBitmap, src_rect.left, src_rect.top,
-                                        blend_mode, NULL, FALSE, pIccTransform)) {
-            return FALSE;
+                                        blend_mode, NULL, false, pIccTransform)) {
+            return false;
         }
         FX_RECT src_rect(0, 0, bg_pixel_width, bg_pixel_height);
         return m_pDeviceDriver->SetDIBits(&background, 0, &src_rect, dest_rect.left, dest_rect.top, FXDIB_BLEND_NORMAL);
     }
     return m_pDeviceDriver->SetDIBits(pBitmap, 0, &src_rect, dest_rect.left, dest_rect.top, blend_mode, 0, pIccTransform);
 }
-FX_BOOL CFX_RenderDevice::StretchDIBits(const CFX_DIBSource* pBitmap, int left, int top,
+bool CFX_RenderDevice::StretchDIBits(const CFX_DIBSource* pBitmap, int left, int top,
                                         int dest_width, int dest_height, FX_DWORD flags,
                                         void* pIccTransform, int blend_mode)
 {
@@ -367,17 +367,17 @@ FX_BOOL CFX_RenderDevice::StretchDIBits(const CFX_DIBSource* pBitmap, int left,
     FX_RECT clip_box = m_ClipBox;
     clip_box.Intersect(dest_rect);
     if (clip_box.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     return m_pDeviceDriver->StretchDIBits(pBitmap, 0, left, top, dest_width, dest_height, &clip_box, flags, 0, pIccTransform, blend_mode);
 }
-FX_BOOL CFX_RenderDevice::SetBitMask(const CFX_DIBSource* pBitmap, int left, int top, FX_DWORD argb,
+bool CFX_RenderDevice::SetBitMask(const CFX_DIBSource* pBitmap, int left, int top, FX_DWORD argb,
                                      int alpha_flag, void* pIccTransform)
 {
     FX_RECT src_rect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
     return m_pDeviceDriver->SetDIBits(pBitmap, argb, &src_rect, left, top, FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_RenderDevice::StretchBitMask(const CFX_DIBSource* pBitmap, int left, int top,
+bool CFX_RenderDevice::StretchBitMask(const CFX_DIBSource* pBitmap, int left, int top,
         int dest_width, int dest_height, FX_DWORD argb, FX_DWORD flags,
         int alpha_flag, void* pIccTransform)
 {
@@ -386,13 +386,13 @@ FX_BOOL CFX_RenderDevice::StretchBitMask(const CFX_DIBSource* pBitmap, int left,
     clip_box.Intersect(dest_rect);
     return m_pDeviceDriver->StretchDIBits(pBitmap, argb, left, top, dest_width, dest_height, &clip_box, flags, alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_RenderDevice::StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD argb,
+bool CFX_RenderDevice::StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD argb,
                                       const CFX_AffineMatrix* pMatrix, FX_DWORD flags, void*& handle,
                                       int alpha_flag, void* pIccTransform, int blend_mode)
 {
     return m_pDeviceDriver->StartDIBits(pBitmap, bitmap_alpha, argb, pMatrix, flags, handle, alpha_flag, pIccTransform, blend_mode);
 }
-FX_BOOL CFX_RenderDevice::ContinueDIBits(void* handle, IFX_Pause* pPause)
+bool CFX_RenderDevice::ContinueDIBits(void* handle, IFX_Pause* pPause)
 {
     return m_pDeviceDriver->ContinueDIBits(handle, pPause);
 }
diff --git a/core/src/fxge/ge/fx_ge_font.cpp b/core/src/fxge/ge/fx_ge_font.cpp
index 6a950bf20b..7a5e0ccabd 100644
--- a/core/src/fxge/ge/fx_ge_font.cpp
+++ b/core/src/fxge/ge/fx_ge_font.cpp
@@ -13,8 +13,8 @@ CFX_Font::CFX_Font()
 {
     m_pSubstFont = NULL;
     m_Face = NULL;
-    m_bEmbedded = FALSE;
-    m_bVertical = FALSE;
+    m_bEmbedded = false;
+    m_bVertical = false;
     m_pFontData = NULL;
     m_pFontDataAllocation = NULL;
     m_dwSize = 0;
@@ -24,7 +24,7 @@ CFX_Font::CFX_Font()
     m_pPlatformFontCollection = NULL;
     m_pDwFont = NULL;
     m_hHandle = NULL;
-    m_bDwLoaded = FALSE;
+    m_bDwLoaded = false;
 }
 CFX_Font::~CFX_Font()
 {
@@ -61,10 +61,10 @@ void CFX_Font::DeleteFace()
     FXFT_Done_Face(m_Face);
     m_Face = NULL;
 }
-FX_BOOL CFX_Font::LoadSubst(const CFX_ByteString& face_name, FX_BOOL bTrueType, FX_DWORD flags,
-                            int weight, int italic_angle, int CharsetCP, FX_BOOL bVertical)
+bool CFX_Font::LoadSubst(const CFX_ByteString& face_name, bool bTrueType, FX_DWORD flags,
+                            int weight, int italic_angle, int CharsetCP, bool bVertical)
 {
-    m_bEmbedded = FALSE;
+    m_bEmbedded = false;
     m_bVertical = bVertical;
     m_pSubstFont = new CFX_SubstFont;
     m_Face = CFX_GEModule::Get()->GetFontMgr()->FindSubstFont(face_name, bTrueType, flags, weight, italic_angle,
@@ -79,7 +79,7 @@ FX_BOOL CFX_Font::LoadSubst(const CFX_ByteString& face_name, FX_BOOL bTrueType,
         m_pFontData = FXFT_Get_Face_Stream_Base(m_Face);
         m_dwSize = FXFT_Get_Face_Stream_Size(m_Face);
     }
-    return TRUE;
+    return true;
 }
 extern "C" {
     unsigned long _FTStreamRead(FXFT_Stream stream, unsigned long offset,
@@ -99,7 +99,7 @@ extern "C" {
     {
     }
 };
-FX_BOOL _LoadFile(FXFT_Library library, FXFT_Face* Face, IFX_FileRead* pFile, FXFT_Stream* stream)
+bool _LoadFile(FXFT_Library library, FXFT_Face* Face, IFX_FileRead* pFile, FXFT_Stream* stream)
 {
     FXFT_Stream stream1 = (FXFT_Stream)FX_Alloc(uint8_t, sizeof (FXFT_StreamRec));
     stream1->base = NULL;
@@ -113,16 +113,16 @@ FX_BOOL _LoadFile(FXFT_Library library, FXFT_Face* Face, IFX_FileRead* pFile, FX
     args.stream = stream1;
     if (FXFT_Open_Face(library, &args, 0, Face)) {
         FX_Free(stream1);
-        return FALSE;
+        return false;
     }
     if (stream) {
         *stream = stream1;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_Font::LoadFile(IFX_FileRead* pFile)
+bool CFX_Font::LoadFile(IFX_FileRead* pFile)
 {
-    m_bEmbedded = FALSE;
+    m_bEmbedded = false;
     FXFT_Library library;
     if (CFX_GEModule::Get()->GetFontMgr()->m_FTLibrary == NULL) {
         FXFT_Init_FreeType(&CFX_GEModule::Get()->GetFontMgr()->m_FTLibrary);
@@ -130,11 +130,11 @@ FX_BOOL CFX_Font::LoadFile(IFX_FileRead* pFile)
     library = CFX_GEModule::Get()->GetFontMgr()->m_FTLibrary;
     FXFT_Stream stream = NULL;
     if (!_LoadFile(library, &m_Face, pFile, &stream)) {
-        return FALSE;
+        return false;
     }
     m_pOwnedStream = stream;
     FXFT_Set_Pixel_Sizes(m_Face, 0, 64);
-    return TRUE;
+    return true;
 }
 int CFX_Font::GetGlyphWidth(FX_DWORD glyph_index)
 {
@@ -169,20 +169,20 @@ static FXFT_Face FT_LoadFont(uint8_t* pData, int size)
     }
     return face;
 }
-FX_BOOL CFX_Font::LoadEmbedded(const uint8_t* data, FX_DWORD size)
+bool CFX_Font::LoadEmbedded(const uint8_t* data, FX_DWORD size)
 {
     m_pFontDataAllocation = FX_Alloc(uint8_t, size);
     FXSYS_memcpy(m_pFontDataAllocation, data, size);
     m_Face = FT_LoadFont((uint8_t*)m_pFontDataAllocation, size);
     m_pFontData = (uint8_t*)m_pFontDataAllocation;
-    m_bEmbedded = TRUE;
+    m_bEmbedded = true;
     m_dwSize = size;
     return m_Face != NULL;
 }
-FX_BOOL CFX_Font::IsTTFont()
+bool CFX_Font::IsTTFont()
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
     return FXFT_Is_Face_TT_OT(m_Face) == FXFT_FACE_FLAG_SFNT;
 }
@@ -202,25 +202,25 @@ int CFX_Font::GetDescent() const
     int descent = EM_ADJUST(FXFT_Get_Face_UnitsPerEM(m_Face), FXFT_Get_Face_Descender(m_Face));
     return descent;
 }
-FX_BOOL CFX_Font::GetGlyphBBox(FX_DWORD glyph_index, FX_RECT &bbox)
+bool CFX_Font::GetGlyphBBox(FX_DWORD glyph_index, FX_RECT &bbox)
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
     if (FXFT_Is_Face_Tricky(m_Face)) {
         int error = FXFT_Set_Char_Size(m_Face, 0, 1000 * 64, 72, 72);
         if (error) {
-            return FALSE;
+            return false;
         }
         error = FXFT_Load_Glyph(m_Face, glyph_index, FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
         if (error) {
-            return FALSE;
+            return false;
         }
         FXFT_BBox cbox;
         FT_Glyph glyph;
         error = FXFT_Get_Glyph(((FXFT_Face)m_Face)->glyph, &glyph);
         if (error) {
-            return FALSE;
+            return false;
         }
         FXFT_Glyph_Get_CBox(glyph, FXFT_GLYPH_BBOX_PIXELS, &cbox);
         int pixel_size_x = ((FXFT_Face)m_Face)->size->metrics.x_ppem,
@@ -246,7 +246,7 @@ FX_BOOL CFX_Font::GetGlyphBBox(FX_DWORD glyph_index, FX_RECT &bbox)
         return FXFT_Set_Pixel_Sizes(m_Face, 0, 64) == 0;
     }
     if (FXFT_Load_Glyph(m_Face, glyph_index, FXFT_LOAD_NO_SCALE | FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH)) {
-        return FALSE;
+        return false;
     }
     int em = FXFT_Get_Face_UnitsPerEM(m_Face);
     if (em == 0) {
@@ -260,34 +260,34 @@ FX_BOOL CFX_Font::GetGlyphBBox(FX_DWORD glyph_index, FX_RECT &bbox)
         bbox.right = (FXFT_Get_Glyph_HoriBearingX(m_Face) + FXFT_Get_Glyph_Width(m_Face)) * 1000 / em;
         bbox.bottom = (FXFT_Get_Glyph_HoriBearingY(m_Face)) * 1000 / em;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_Font::IsItalic()
+bool CFX_Font::IsItalic()
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL ret = FXFT_Is_Face_Italic(m_Face) == FXFT_STYLE_FLAG_ITALIC;
+    bool ret = FXFT_Is_Face_Italic(m_Face) == FXFT_STYLE_FLAG_ITALIC;
     if (!ret) {
         CFX_ByteString str(FXFT_Get_Face_Style_Name(m_Face));
         str.MakeLower();
         if (str.Find("italic") != -1) {
-            ret = TRUE;
+            ret = true;
         }
     }
     return ret;
 }
-FX_BOOL CFX_Font::IsBold()
+bool CFX_Font::IsBold()
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
     return FXFT_Is_Face_Bold(m_Face) == FXFT_STYLE_FLAG_BOLD;
 }
-FX_BOOL CFX_Font::IsFixedWidth()
+bool CFX_Font::IsFixedWidth()
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
     return FXFT_Is_Face_fixedwidth(m_Face);
 }
@@ -331,10 +331,10 @@ CFX_ByteString CFX_Font::GetFaceName() const
     }
     return m_pSubstFont->m_Family;
 }
-FX_BOOL CFX_Font::GetBBox(FX_RECT &bbox)
+bool CFX_Font::GetBBox(FX_RECT &bbox)
 {
     if (m_Face == NULL) {
-        return FALSE;
+        return false;
     }
     int em = FXFT_Get_Face_UnitsPerEM(m_Face);
     if (em == 0) {
@@ -348,7 +348,7 @@ FX_BOOL CFX_Font::GetBBox(FX_RECT &bbox)
         bbox.right = FXFT_Get_Face_xMax(m_Face) * 1000 / em;
         bbox.bottom = FXFT_Get_Face_yMax(m_Face) * 1000 / em;
     }
-    return TRUE;
+    return true;
 }
 int CFX_Font::GetHeight()
 {
diff --git a/core/src/fxge/ge/fx_ge_fontmap.cpp b/core/src/fxge/ge/fx_ge_fontmap.cpp
index 14427a5e40..15f022e86b 100644
--- a/core/src/fxge/ge/fx_ge_fontmap.cpp
+++ b/core/src/fxge/ge/fx_ge_fontmap.cpp
@@ -18,9 +18,9 @@ CFX_SubstFont::CFX_SubstFont()
     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()
 {
@@ -38,11 +38,11 @@ CTTFontDesc::~CTTFontDesc()
         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;
@@ -51,15 +51,15 @@ FX_BOOL CTTFontDesc::ReleaseFace(FXFT_Face 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()
 {
@@ -98,7 +98,7 @@ 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) {
@@ -115,7 +115,7 @@ FXFT_Face CFX_FontMgr::FindSubstFont(const CFX_ByteString& face_name, FX_BOOL bT
                                            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 += ',';
@@ -131,7 +131,7 @@ FXFT_Face CFX_FontMgr::GetCachedFace(const CFX_ByteString& face_name,
     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;
@@ -433,10 +433,10 @@ 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) {
@@ -452,14 +452,14 @@ FX_BOOL CFX_FontMgr::GetStandardFont(const uint8_t*& pFontData, FX_DWORD& size,
             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()
@@ -583,10 +583,10 @@ void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset)
         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) {
@@ -620,7 +620,7 @@ void CFX_FontMapper::LoadInstalledFonts()
         return;
     }
     m_pFontInfo->EnumFontList(this);
-    m_bListLoaded = TRUE;
+    m_bListLoaded = true;
 }
 CFX_ByteString CFX_FontMapper::MatchInstalledFonts(const CFX_ByteString& norm_name)
 {
@@ -847,7 +847,7 @@ CFX_ByteString ParseStyle(const FX_CHAR* pStyle, int iLen, int 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) {
@@ -872,15 +872,15 @@ int32_t GetStyleType(const CFX_ByteString &bsStyle, FX_BOOL bRevert)
     }
     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)) {
@@ -923,14 +923,14 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
     }
     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;
     }
@@ -939,9 +939,9 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
             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) {
@@ -962,12 +962,12 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
             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) {
@@ -995,17 +995,17 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
         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) {
@@ -1013,7 +1013,7 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
                 } else {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
-                bFirstItem = FALSE;
+                bFirstItem = false;
             }
             if (nRet == 1) {
                 if (bFirstItem) {
@@ -1031,7 +1031,7 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
                 } else {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
-                bFirstItem = FALSE;
+                bFirstItem = false;
             }
             i += buf.GetLength() + 1;
         }
@@ -1042,9 +1042,9 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
         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;
+    bool bCJK = false;
     int iExact = 0;
     int Charset = FXFONT_ANSI_CHARSET;
     if (WindowCP) {
@@ -1054,7 +1054,7 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
     }
     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;
@@ -1069,21 +1069,21 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
         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 {
@@ -1123,7 +1123,7 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
         }
     } else {
         if (flags & FXFONT_ITALIC) {
-            bItalic = TRUE;
+            bItalic = true;
         }
     }
     iExact = !match.IsEmpty();
@@ -1134,9 +1134,9 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
     if (hFont == NULL) {
         if (bCJK) {
             if (italic_angle != 0) {
-                bItalic = TRUE;
+                bItalic = true;
             } else {
-                bItalic = FALSE;
+                bItalic = false;
             }
             weight = old_weight;
         }
@@ -1221,18 +1221,18 @@ FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTru
     }
     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) {
@@ -1262,7 +1262,7 @@ CFontFileFaceInfo::CFontFileFaceInfo()
     m_FileSize = 0;
     m_FontOffset = 0;
     m_Weight = 0;
-    m_bItalic = FALSE;
+    m_bItalic = false;
     m_PitchFamily = 0;
 }
 CFontFileFaceInfo::~CFontFileFaceInfo()
@@ -1272,7 +1272,7 @@ CFontFileFaceInfo::~CFontFileFaceInfo()
     }
     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()
 {
@@ -1300,13 +1300,13 @@ 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)
 {
@@ -1315,7 +1315,7 @@ void CFX_FolderFontInfo::ScanPath(CFX_ByteString& path)
         return;
     }
     CFX_ByteString filename;
-    FX_BOOL bFolder;
+    bool bFolder;
     while (FX_GetNextFile(handle, filename, bFolder)) {
         if (bFolder) {
             if (filename == "." || filename == "..") {
@@ -1451,7 +1451,7 @@ void CFX_FolderFontInfo::ReportFace(CFX_ByteString& path, FXSYS_FILE* pFile, FX_
     }
     m_FontList.SetAt(facename, pInfo);
 }
-void* CFX_FolderFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, int& iExact)
+void* CFX_FolderFontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, int& iExact)
 {
     return NULL;
 }
@@ -1506,16 +1506,16 @@ FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont, FX_DWORD table, uint8_t* b
 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;
 }
diff --git a/core/src/fxge/ge/fx_ge_linux.cpp b/core/src/fxge/ge/fx_ge_linux.cpp
index 861afd259c..9f493a6cfc 100644
--- a/core/src/fxge/ge/fx_ge_linux.cpp
+++ b/core/src/fxge/ge/fx_ge_linux.cpp
@@ -30,9 +30,9 @@ Base14Substs[] = {
 class CFX_LinuxFontInfo : public CFX_FolderFontInfo
 {
 public:
-    void* MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, int& iExact) override;
-    FX_BOOL				ParseFontCfg();
-    void*				FindFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, FX_BOOL bMatchName);
+    void* MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, int& iExact) override;
+    bool				ParseFontCfg();
+    void*				FindFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, bool bMatchName);
 };
 #define LINUX_GPNAMESIZE	6
 static const struct {
@@ -77,7 +77,7 @@ static int32_t GetJapanesePreference(const FX_CHAR* facearr, int weight, int pic
     }
     return 2;
 }
-void* CFX_LinuxFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, int& iExact)
+void* CFX_LinuxFontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, int& iExact)
 {
     CFX_ByteString face = cstr_face;
     int iBaseFont;
@@ -91,7 +91,7 @@ void* CFX_LinuxFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int p
         return GetFont(face);
     }
     void* p = NULL;
-    FX_BOOL bCJK = TRUE;
+    bool bCJK = true;
     switch (charset) {
         case FXFONT_SHIFTJIS_CHARSET: {
                 int32_t index = GetJapanesePreference(cstr_face, weight, pitch_family);
@@ -129,7 +129,7 @@ void* CFX_LinuxFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int p
             }
             break;
         default:
-            bCJK = FALSE;
+            bCJK = false;
             break;
     }
     if (charset == FXFONT_ANSI_CHARSET && (pitch_family & FXFONT_FF_FIXEDPITCH)) {
@@ -157,7 +157,7 @@ static FX_DWORD _LinuxGetCharset(int charset)
     }
     return 0;
 }
-static int32_t _LinuxGetSimilarValue(int weight, FX_BOOL bItalic, int pitch_family, FX_DWORD style)
+static int32_t _LinuxGetSimilarValue(int weight, bool bItalic, int pitch_family, FX_DWORD style)
 {
     int32_t iSimilarValue = 0;
     if ((style & FXFONT_BOLD) == (weight > 400)) {
@@ -177,7 +177,7 @@ static int32_t _LinuxGetSimilarValue(int weight, FX_BOOL bItalic, int pitch_fami
     }
     return iSimilarValue;
 }
-void* CFX_LinuxFontInfo::FindFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, FX_BOOL bMatchName)
+void* CFX_LinuxFontInfo::FindFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* family, bool bMatchName)
 {
     CFontFaceInfo* pFind = NULL;
     FX_DWORD charset_flag = _LinuxGetCharset(charset);
@@ -217,9 +217,9 @@ IFX_SystemFontInfo* IFX_SystemFontInfo::CreateDefault()
     }
     return pInfo;
 }
-FX_BOOL CFX_LinuxFontInfo::ParseFontCfg()
+bool CFX_LinuxFontInfo::ParseFontCfg()
 {
-    return FALSE;
+    return false;
 }
 void CFX_GEModule::InitPlatform()
 {
diff --git a/core/src/fxge/ge/fx_ge_path.cpp b/core/src/fxge/ge/fx_ge_path.cpp
index b1410b3911..4bc9a88128 100644
--- a/core/src/fxge/ge/fx_ge_path.cpp
+++ b/core/src/fxge/ge/fx_ge_path.cpp
@@ -110,7 +110,7 @@ void CFX_ClipRgn::IntersectMaskF(int left, int top, CFX_DIBitmapRef Mask)
         m_Mask = new_mask;
         return;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
 }
 CFX_PathData::CFX_PathData()
 {
@@ -257,8 +257,8 @@ static void _UpdateLineJoinPoints(CFX_FloatRect& rect, FX_FLOAT start_x, FX_FLOA
                                   FX_FLOAT half_width, FX_FLOAT miter_limit)
 {
     FX_FLOAT start_k = 0, start_c = 0, end_k = 0, end_c = 0, start_len = 0, start_dc = 0, end_len = 0, end_dc = 0;
-    FX_BOOL bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
-    FX_BOOL bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
+    bool bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
+    bool bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
     if (bStartVert && bEndVert) {
         int start_dir = middle_y > start_y ? 1 : -1;
         FX_FLOAT point_y = middle_y + half_width * start_dir;
@@ -342,12 +342,12 @@ CFX_FloatRect CFX_PathData::GetBoundingBox(FX_FLOAT line_width, FX_FLOAT miter_l
     int iPoint = 0;
     FX_FLOAT half_width = line_width;
     int iStartPoint, iEndPoint, iMiddlePoint;
-    FX_BOOL bJoin;
+    bool bJoin;
     while (iPoint < m_PointCount) {
         if (m_pPoints[iPoint].m_Flag == FXPT_MOVETO) {
             iStartPoint = iPoint + 1;
             iEndPoint = iPoint;
-            bJoin = FALSE;
+            bJoin = false;
         } else {
             if (m_pPoints[iPoint].m_Flag == FXPT_BEZIERTO) {
                 rect.UpdateRect(m_pPoints[iPoint].m_PointX, m_pPoints[iPoint].m_PointY);
@@ -357,12 +357,12 @@ CFX_FloatRect CFX_PathData::GetBoundingBox(FX_FLOAT line_width, FX_FLOAT miter_l
             if (iPoint == m_PointCount - 1 || m_pPoints[iPoint + 1].m_Flag == FXPT_MOVETO) {
                 iStartPoint = iPoint - 1;
                 iEndPoint = iPoint;
-                bJoin = FALSE;
+                bJoin = false;
             } else {
                 iStartPoint = iPoint - 1;
                 iMiddlePoint = iPoint;
                 iEndPoint = iPoint + 1;
-                bJoin = TRUE;
+                bJoin = true;
             }
         }
         FX_FLOAT start_x = m_pPoints[iStartPoint].m_PointX;
@@ -389,10 +389,10 @@ void CFX_PathData::Transform(const CFX_AffineMatrix* pMatrix)
         pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY);
     }
 }
-FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* pMatrix, FX_BOOL&bThin, FX_BOOL bAdjust) const
+bool CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* pMatrix, bool&bThin, bool bAdjust) const
 {
     if (m_PointCount < 3) {
-        return FALSE;
+        return false;
     }
     if (m_PointCount == 3 && (m_pPoints[0].m_Flag & FXPT_TYPE) == FXPT_MOVETO &&
             (m_pPoints[1].m_Flag & FXPT_TYPE) == FXPT_LINETO && (m_pPoints[2].m_Flag & FXPT_TYPE) == FXPT_LINETO
@@ -422,19 +422,19 @@ FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* p
             NewPath.SetPoint(1, m_pPoints[1].m_PointX, m_pPoints[1].m_PointY, FXPT_LINETO);
         }
         if (m_pPoints[0].m_PointX != m_pPoints[1].m_PointX && m_pPoints[0].m_PointY != m_pPoints[1].m_PointY) {
-            bThin = TRUE;
+            bThin = true;
         }
-        return TRUE;
+        return true;
     }
     if (((m_PointCount > 3) && (m_PointCount % 2))) {
         int mid = m_PointCount / 2;
-        FX_BOOL bZeroArea = FALSE;
+        bool bZeroArea = false;
         CFX_PathData t_path;
         for (int i = 0; i < mid; i++) {
             if (!(m_pPoints[mid - i - 1].m_PointX == m_pPoints[mid + i + 1].m_PointX
                     && m_pPoints[mid - i - 1].m_PointY == m_pPoints[mid + i + 1].m_PointY &&
                     ((m_pPoints[mid - i - 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO && (m_pPoints[mid + i + 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO))) {
-                bZeroArea = TRUE;
+                bZeroArea = true;
                 break;
             }
             int new_count = t_path.GetPointCount();
@@ -444,8 +444,8 @@ FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* p
         }
         if (!bZeroArea) {
             NewPath.Append(&t_path, NULL);
-            bThin = TRUE;
-            return TRUE;
+            bThin = true;
+            return true;
         }
     }
     int stratPoint = 0;
@@ -488,7 +488,7 @@ FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* p
                     NewPath.AddPointCount(2);
                     NewPath.SetPoint(new_count, m_pPoints[i - 1].m_PointX, m_pPoints[i - 1].m_PointY, FXPT_MOVETO);
                     NewPath.SetPoint(new_count + 1, m_pPoints[i].m_PointX, m_pPoints[i].m_PointY, FXPT_LINETO);
-                    bThin = TRUE;
+                    bThin = true;
                 }
             }
         } else if (point_type == FXPT_BEZIERTO) {
@@ -497,42 +497,42 @@ FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* p
         }
     }
     if (m_PointCount > 3 && NewPath.GetPointCount()) {
-        bThin = TRUE;
+        bThin = true;
     }
     if (NewPath.GetPointCount() == 0) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_PathData::IsRect() const
+bool CFX_PathData::IsRect() const
 {
     if (m_PointCount != 5 && m_PointCount != 4) {
-        return FALSE;
+        return false;
     }
     if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX ||
                                m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
             (m_pPoints[0].m_PointX == m_pPoints[2].m_PointX && m_pPoints[0].m_PointY == m_pPoints[2].m_PointY) ||
             (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX && m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-        return FALSE;
+        return false;
     }
     if (m_pPoints[0].m_PointX != m_pPoints[3].m_PointX && m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-        return FALSE;
+        return false;
     }
     for (int i = 1; i < 4; i ++) {
         if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-            return FALSE;
+            return false;
         }
         if (m_pPoints[i].m_PointX != m_pPoints[i - 1].m_PointX && m_pPoints[i].m_PointY != m_pPoints[i - 1].m_PointY) {
-            return FALSE;
+            return false;
         }
     }
     return m_PointCount == 5 || (m_pPoints[3].m_Flag & FXPT_CLOSEFIGURE);
 }
-FX_BOOL CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRect) const
+bool CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRect) const
 {
     if (pMatrix == NULL) {
         if (!IsRect()) {
-            return FALSE;
+            return false;
         }
         if (pRect) {
             pRect->left = m_pPoints[0].m_PointX;
@@ -541,27 +541,27 @@ FX_BOOL CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRe
             pRect->top = m_pPoints[2].m_PointY;
             pRect->Normalize();
         }
-        return TRUE;
+        return true;
     }
     if (m_PointCount != 5 && m_PointCount != 4) {
-        return FALSE;
+        return false;
     }
     if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX || m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
             (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX && m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-        return FALSE;
+        return false;
     }
     if (m_PointCount == 4 && m_pPoints[0].m_PointX != m_pPoints[3].m_PointX && m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT x[5], y[5];
     for (int i = 0; i < m_PointCount; i ++) {
         pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY, x[i], y[i]);
         if (i) {
             if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-                return FALSE;
+                return false;
             }
             if (x[i] != x[i - 1] && y[i] != y[i - 1]) {
-                return FALSE;
+                return false;
             }
         }
     }
@@ -572,7 +572,7 @@ FX_BOOL CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRe
         pRect->top = y[2];
         pRect->Normalize();
     }
-    return TRUE;
+    return true;
 }
 void CFX_PathData::Copy(const CFX_PathData &src)
 {
diff --git a/core/src/fxge/ge/fx_ge_ps.cpp b/core/src/fxge/ge/fx_ge_ps.cpp
index ba5c5fbabb..e375288247 100644
--- a/core/src/fxge/ge/fx_ge_ps.cpp
+++ b/core/src/fxge/ge/fx_ge_ps.cpp
@@ -10,7 +10,7 @@
 struct PSGlyph {
     CFX_Font*		m_pFont;
     FX_DWORD		m_GlyphIndex;
-    FX_BOOL			m_bGlyphAdjust;
+    bool			m_bGlyphAdjust;
     FX_FLOAT		m_AdjustMatrix[4];
 };
 class CPSFont
@@ -22,8 +22,8 @@ public:
 CFX_PSRenderer::CFX_PSRenderer()
 {
     m_pOutput = NULL;
-    m_bColorSet = m_bGraphStateSet = FALSE;
-    m_bInited = FALSE;
+    m_bColorSet = m_bGraphStateSet = false;
+    m_bInited = false;
 }
 CFX_PSRenderer::~CFX_PSRenderer()
 {
@@ -33,7 +33,7 @@ CFX_PSRenderer::~CFX_PSRenderer()
     }
 }
 #define OUTPUT_PS(str) m_pOutput->OutputPS(str, sizeof str-1)
-void CFX_PSRenderer::Init(IFX_PSOutput* pOutput, int pslevel, int width, int height, FX_BOOL bCmykOutput)
+void CFX_PSRenderer::Init(IFX_PSOutput* pOutput, int pslevel, int width, int height, bool bCmykOutput)
 {
     m_PSLevel = pslevel;
     m_pOutput = pOutput;
@@ -42,10 +42,10 @@ void CFX_PSRenderer::Init(IFX_PSOutput* pOutput, int pslevel, int width, int hei
     m_ClipBox.bottom = height;
     m_bCmykOutput = bCmykOutput;
 }
-FX_BOOL CFX_PSRenderer::StartRendering()
+bool CFX_PSRenderer::StartRendering()
 {
     if (m_bInited) {
-        return TRUE;
+        return true;
     }
     static const char init_str[] = "\nsave\n/im/initmatrix load def\n"
                                    "/n/newpath load def/m/moveto load def/l/lineto load def/c/curveto load def/h/closepath load def\n"
@@ -57,15 +57,15 @@ FX_BOOL CFX_PSRenderer::StartRendering()
                                    "/cm/concat load def/Cm/currentmatrix load def/mx/matrix load def/sm/setmatrix load def\n"
                                    ;
     OUTPUT_PS(init_str);
-    m_bInited = TRUE;
-    return TRUE;
+    m_bInited = true;
+    return true;
 }
 void CFX_PSRenderer::EndRendering()
 {
     if (m_bInited) {
         OUTPUT_PS("\nrestore\n");
     }
-    m_bInited = FALSE;
+    m_bInited = false;
 }
 void CFX_PSRenderer::SaveState()
 {
@@ -73,7 +73,7 @@ void CFX_PSRenderer::SaveState()
     OUTPUT_PS("q\n");
     m_ClipBoxStack.Add(m_ClipBox);
 }
-void CFX_PSRenderer::RestoreState(FX_BOOL bKeepSaved)
+void CFX_PSRenderer::RestoreState(bool bKeepSaved)
 {
     StartRendering();
     if (bKeepSaved) {
@@ -81,7 +81,7 @@ void CFX_PSRenderer::RestoreState(FX_BOOL bKeepSaved)
     } else {
         OUTPUT_PS("Q\n");
     }
-    m_bColorSet = m_bGraphStateSet = FALSE;
+    m_bColorSet = m_bGraphStateSet = false;
     m_ClipBox = m_ClipBoxStack.GetAt(m_ClipBoxStack.GetSize() - 1);
     if (!bKeepSaved) {
         m_ClipBoxStack.RemoveAt(m_ClipBoxStack.GetSize() - 1);
@@ -175,7 +175,7 @@ void CFX_PSRenderer::SetClip_PathStroke(const CFX_PathData* pPathData,
         OUTPUT_PS("strokepath W n\n");
     }
 }
-FX_BOOL CFX_PSRenderer::DrawPath(const CFX_PathData* pPathData,
+bool CFX_PSRenderer::DrawPath(const CFX_PathData* pPathData,
                                  const CFX_AffineMatrix* pObject2Device,
                                  const CFX_GraphStateData* pGraphState,
                                  FX_DWORD fill_color,
@@ -189,13 +189,13 @@ FX_BOOL CFX_PSRenderer::DrawPath(const CFX_PathData* pPathData,
     int fill_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(fill_color);
     int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color);
     if (fill_alpha && fill_alpha < 255) {
-        return FALSE;
+        return false;
     }
     if (stroke_alpha && stroke_alpha < 255) {
-        return FALSE;
+        return false;
     }
     if (fill_alpha == 0 && stroke_alpha == 0) {
-        return FALSE;
+        return false;
     }
     if (stroke_alpha) {
         SetGraphState(pGraphState);
@@ -233,7 +233,7 @@ FX_BOOL CFX_PSRenderer::DrawPath(const CFX_PathData* pPathData,
         }
     }
     OUTPUT_PS("\n");
-    return TRUE;
+    return true;
 }
 void CFX_PSRenderer::SetGraphState(const CFX_GraphStateData* pGraphState)
 {
@@ -259,7 +259,7 @@ void CFX_PSRenderer::SetGraphState(const CFX_GraphStateData* pGraphState)
         buf << pGraphState->m_MiterLimit << FX_BSTRC(" M\n");
     }
     m_CurGraphState.Copy(*pGraphState);
-    m_bGraphStateSet = TRUE;
+    m_bGraphStateSet = true;
     if (buf.GetSize()) {
         m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
     }
@@ -305,7 +305,7 @@ static void PSCompressData(int PSLevel, uint8_t* src_buf, FX_DWORD src_size,
         }
     }
 }
-FX_BOOL CFX_PSRenderer::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int left, int top,
+bool CFX_PSRenderer::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int left, int top,
                                   int alpha_flag, void* pIccTransform)
 {
     StartRendering();
@@ -313,7 +313,7 @@ FX_BOOL CFX_PSRenderer::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
                             (FX_FLOAT)(left), (FX_FLOAT)(top + pSource->GetHeight()));
     return DrawDIBits(pSource, color, &matrix, 0, alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_PSRenderer::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CFX_PSRenderer::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
                                       int dest_width, int dest_height, FX_DWORD flags,
                                       int alpha_flag, void* pIccTransform)
 {
@@ -322,20 +322,20 @@ FX_BOOL CFX_PSRenderer::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD col
                             (FX_FLOAT)(dest_left), (FX_FLOAT)(dest_top + dest_height));
     return DrawDIBits(pSource, color, &matrix, flags, alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
+bool CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
                                    const CFX_AffineMatrix* pMatrix, FX_DWORD flags,
                                    int alpha_flag, void* pIccTransform)
 {
     StartRendering();
     if ((pMatrix->a == 0 && pMatrix->b == 0) || (pMatrix->c == 0 && pMatrix->d == 0)) {
-        return TRUE;
+        return true;
     }
     if (pSource->HasAlpha()) {
-        return FALSE;
+        return false;
     }
     int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(color) : FXARGB_A(color);
     if (pSource->IsAlphaMask() && (alpha < 255 || pSource->GetBPP() != 1)) {
-        return FALSE;
+        return false;
     }
     OUTPUT_PS("q\n");
     CFX_ByteTextBuf buf;
@@ -358,7 +358,7 @@ FX_BOOL CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
         FaxCompressData(src_buf, width, height, output_buf, output_size);
         if (pSource->IsAlphaMask()) {
             SetColor(color, alpha_flag, pIccTransform);
-            m_bColorSet = FALSE;
+            m_bColorSet = false;
             buf << FX_BSTRC(" true[");
         } else {
             buf << FX_BSTRC(" 1[");
@@ -406,7 +406,7 @@ FX_BOOL CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
         }
         if (pConverted == NULL) {
             OUTPUT_PS("\nQ\n");
-            return FALSE;
+            return false;
         }
         int Bpp = pConverted->GetBPP() / 8;
         uint8_t* output_buf = NULL;
@@ -462,14 +462,14 @@ FX_BOOL CFX_PSRenderer::DrawDIBits(const CFX_DIBSource* pSource, FX_DWORD color,
         FX_Free(output_buf);
     }
     OUTPUT_PS("\nQ\n");
-    return TRUE;
+    return true;
 }
 void CFX_PSRenderer::SetColor(FX_DWORD color, int alpha_flag, void* pIccTransform)
 {
     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         pIccTransform = NULL;
     }
-    FX_BOOL bCMYK = FALSE;
+    bool bCMYK = false;
     if (pIccTransform) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         color = FXGETFLAG_COLORTYPE(alpha_flag) ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
@@ -490,7 +490,7 @@ void CFX_PSRenderer::SetColor(FX_DWORD color, int alpha_flag, void* pIccTransfor
                 << FXARGB_B(color) / 255.0 << FX_BSTRC(" rg\n");
         }
         if (bCMYK == m_bCmykOutput) {
-            m_bColorSet = TRUE;
+            m_bColorSet = true;
             m_LastColor = color;
         }
         m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
@@ -588,7 +588,7 @@ void CFX_PSRenderer::FindPSFontGlyph(CFX_FaceCache* pFaceCache, CFX_Font* pFont,
         << FX_BSTRC("/") << ps_glyphindex << FX_BSTRC(" put\n");
     m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
 }
-FX_BOOL CFX_PSRenderer::DrawText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+bool CFX_PSRenderer::DrawText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
                                  CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device,
                                  FX_FLOAT font_size, FX_DWORD color,
                                  int alpha_flag, void* pIccTransform)
@@ -596,10 +596,10 @@ FX_BOOL CFX_PSRenderer::DrawText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX
     StartRendering();
     int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
     if (alpha < 255) {
-        return FALSE;
+        return false;
     }
     if ((pObject2Device->a == 0 && pObject2Device->b == 0) || (pObject2Device->c == 0 && pObject2Device->d == 0)) {
-        return TRUE;
+        return true;
     }
     SetColor(color, alpha_flag, pIccTransform);
     CFX_ByteTextBuf buf;
@@ -628,7 +628,7 @@ FX_BOOL CFX_PSRenderer::DrawText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX
     }
     buf << FX_BSTRC("Q\n");
     m_pOutput->OutputPS((const FX_CHAR*)buf.GetBuffer(), buf.GetSize());
-    return TRUE;
+    return true;
 }
 void CFX_PSRenderer::WritePSBinary(const uint8_t* data, int len)
 {
diff --git a/core/src/fxge/ge/fx_ge_text.cpp b/core/src/fxge/ge/fx_ge_text.cpp
index 59a4cfb37d..c5da66a4ce 100644
--- a/core/src/fxge/ge/fx_ge_text.cpp
+++ b/core/src/fxge/ge/fx_ge_text.cpp
@@ -46,7 +46,7 @@ private:
 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;
@@ -66,7 +66,7 @@ FX_RECT FXGE_GetGlyphsBBox(FXTEXT_GLYPHPOS* pGlyphAndPos, int nChars, int anti_a
             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;
@@ -87,9 +87,9 @@ FX_RECT FXGE_GetGlyphsBBox(FXTEXT_GLYPHPOS* pGlyphAndPos, int nChars, int anti_a
 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;
     }
@@ -155,7 +155,7 @@ void _Color2Argb(FX_ARGB& argb, FX_DWORD color, int alpha_flag, void* pIccTransf
     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,
@@ -171,12 +171,12 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
 #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_
@@ -186,7 +186,7 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
 #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;
@@ -204,24 +204,24 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
         }
     }
     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;
                 }
@@ -278,7 +278,7 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
     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);
@@ -288,7 +288,7 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
         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 ++) {
@@ -308,19 +308,19 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
     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);
@@ -352,13 +352,13 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
         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();
@@ -945,9 +945,9 @@ FX_BOOL CFX_RenderDevice::DrawNormalText(int nChars, const FXTEXT_CHARPOS* pChar
         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,
@@ -973,7 +973,7 @@ FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars, const FXTEXT_CHARPOS* pCharPo
         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) {
@@ -989,24 +989,24 @@ FX_BOOL CFX_RenderDevice::DrawTextPath(int nChars, const FXTEXT_CHARPOS* pCharPo
             }
             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;
@@ -1028,7 +1028,7 @@ CFX_FaceCache* CFX_FontCache::GetCachedFace(CFX_Font* pFont)
 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;
@@ -1043,7 +1043,7 @@ void CFX_FontCache::ReleaseCachedFace(CFX_Font* pFont)
     }
 }
 
-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++;
@@ -1095,7 +1095,7 @@ 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;
@@ -1114,7 +1114,7 @@ CFX_GlyphBitmap* CFX_FaceCache::LookUpGlyphBitmap(CFX_Font* pFont, const CFX_Aff
     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) {
@@ -1311,7 +1311,7 @@ static void _ContrastAdjust(uint8_t* pDataIn, uint8_t* pDataOut, int nWid, int n
         }
     }
 }
-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) {
@@ -1322,7 +1322,7 @@ CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont, FX_DWORD glyph_inde
     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;
@@ -1422,18 +1422,18 @@ CFX_GlyphBitmap* CFX_FaceCache::RenderGlyph(CFX_Font* pFont, FX_DWORD glyph_inde
     }
     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));
@@ -1451,13 +1451,13 @@ FX_BOOL _OutputGlyph(void* dib, int x, int y, CFX_Font* pFont,
         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);
@@ -1490,9 +1490,9 @@ FX_BOOL OutputText(void* dib, int x, int y, CFX_Font* pFont, double font_size,
     }
     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;
@@ -1507,7 +1507,7 @@ FX_BOOL OutputGlyph(void* dib, int x, int y, CFX_Font* pFont, double font_size,
         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;
 }
@@ -1533,7 +1533,7 @@ const CFX_PathData* CFX_FaceCache::LoadGlyphPath(CFX_Font* pFont, FX_DWORD glyph
     return pGlyphPath;
 }
 typedef struct {
-    FX_BOOL			m_bCount;
+    bool			m_bCount;
     int				m_PointCount;
     FX_PATHPOINT*	m_pPoints;
     int				m_CurX;
@@ -1684,7 +1684,7 @@ CFX_PathData* CFX_Font::LoadGlyphPath(FX_DWORD glyph_index, int dest_width)
     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) {
@@ -1692,7 +1692,7 @@ CFX_PathData* CFX_Font::LoadGlyphPath(FX_DWORD glyph_index, int dest_width)
     }
     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;
diff --git a/core/src/fxge/ge/text_int.h b/core/src/fxge/ge/text_int.h
index 12fac6a60a..2e861baf1b 100644
--- a/core/src/fxge/ge/text_int.h
+++ b/core/src/fxge/ge/text_int.h
@@ -32,12 +32,12 @@ public:
         m_RefCount = 0;
     }
     ~CTTFontDesc();
-    FX_BOOL			ReleaseFace(FXFT_Face face);
+    bool			ReleaseFace(FXFT_Face face);
     int				m_Type;
     union {
         struct {
-            FX_BOOL		m_bItalic;
-            FX_BOOL		m_bBold;
+            bool		m_bItalic;
+            bool		m_bBold;
             FXFT_Face	m_pFace;
         } m_SingleFace;
         struct {
@@ -63,9 +63,9 @@ private:
     {
         return Unicode;
     }
-    virtual FX_BOOL			IsUnicodeCompatible() const
+    virtual bool			IsUnicodeCompatible() const
     {
-        return TRUE;
+        return true;
     }
 };
 #define CHARSET_FLAG_ANSI		1
@@ -97,7 +97,7 @@ public:
     FX_DWORD			m_FileSize;
     FX_DWORD			m_FontOffset;
     int					m_Weight;
-    FX_BOOL				m_bItalic;
+    bool				m_bItalic;
     int					m_PitchFamily;
     CFX_ByteString		m_FontTables;
 };
diff --git a/core/src/fxge/skia/fx_skia_blitter_new.cpp b/core/src/fxge/skia/fx_skia_blitter_new.cpp
index 3437eb497d..13bb753e45 100644
--- a/core/src/fxge/skia/fx_skia_blitter_new.cpp
+++ b/core/src/fxge/skia/fx_skia_blitter_new.cpp
@@ -1298,7 +1298,7 @@
 
 
     //--------------------------------------------------------------------
-    FX_BOOL CFX_SkiaRenderer::Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder,
+    bool CFX_SkiaRenderer::Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, bool bFullCover, bool bRgbByteOrder,
         int alpha_flag, void* pIccTransform) //The alpha flag must be fill_flag if exist.
     {
         m_pDevice = pDevice;
@@ -1331,8 +1331,8 @@
 
         m_bFullCover = bFullCover;
 
-        FX_BOOL bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
-        FX_BOOL bDeviceCMYK = pDevice->IsCmykImage();
+        bool bObjectCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
+        bool bDeviceCMYK = pDevice->IsCmykImage();
 
         m_Alpha = bObjectCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
 
@@ -1377,7 +1377,7 @@
                         pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&m_Color, 1);
                 } else { // Object RGB
                     if (!pIccTransform)
-                        return FALSE;
+                        return false;
                     color = FXARGB_TODIB(color);
                     pIccModule->TranslateScanline(pIccTransform, (uint8_t*)&m_Color, (const uint8_t*)&color, 1);
                 }
@@ -1385,7 +1385,7 @@
                 m_Green = ((uint8_t*)&m_Color)[1];
                 m_Blue  = ((uint8_t*)&m_Color)[2];
                 m_Gray  = ((uint8_t*)&m_Color)[3];
-                return TRUE;
+                return true;
             }
             if (pIccTransform) {
                 color = bObjectCMYK ? FXCMYK_TODIB(color) : FXARGB_TODIB(color);
@@ -1496,8 +1496,8 @@
                 break;
         }
         if (composite_span == NULL)
-            return FALSE;
-        return TRUE;
+            return false;
+        return true;
     }
 
     /*----------------------------------------------------------------------------------------------------*/
@@ -1595,7 +1595,7 @@
         blitV(x, y, height, rightAlpha);
     }
 
-    FX_BOOL CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int Top)
+    bool CFX_SkiaA8Renderer::Init(CFX_DIBitmap* pDevice, int Left, int Top)
     {
         m_pDevice = pDevice;
         m_Left = Left;
@@ -1604,6 +1604,6 @@
             m_dstWidth = m_Left + pDevice->GetWidth();
             m_dstHeight = m_Top + pDevice->GetHeight();
         }
-        return TRUE;
+        return true;
     }
 #endif
diff --git a/core/src/fxge/skia/fx_skia_blitter_new.h b/core/src/fxge/skia/fx_skia_blitter_new.h
index e60c6398d2..cd411da9f5 100644
--- a/core/src/fxge/skia/fx_skia_blitter_new.h
+++ b/core/src/fxge/skia/fx_skia_blitter_new.h
@@ -15,9 +15,9 @@ protected:
 				m_Blue,		// Yellow
 				m_Gray;		// Black
 	FX_DWORD	m_Color;	// FX_ARGB or FX_CMYK
-	FX_BOOL		m_bFullCover;
+	bool		m_bFullCover;
 	int			m_ProcessFilter;
-	FX_BOOL     m_bRgbByteOrder;
+	bool     m_bRgbByteOrder;
 
 	FX_RECT				m_ClipBox;
 	CFX_DIBitmap*		m_pDevice;
@@ -205,7 +205,7 @@ public:
 
 
 	//--------------------------------------------------------------------
-	FX_BOOL Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bRgbByteOrder,
+	bool Init(CFX_DIBitmap* pDevice, CFX_DIBitmap* pOriDevice, const CFX_ClipRgn* pClipRgn, FX_DWORD color, bool bFullCover, bool bRgbByteOrder,
 		int alpha_flag = 0, void* pIccTransform = NULL); //The alpha flag must be fill_flag if exist.
 };
 class CFX_SkiaA8Renderer : public SkBlitter
@@ -218,7 +218,7 @@ public:
 	virtual void blitRect(int x, int y, int width, int height);
 	virtual	void blitAntiRect(int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha);
 	//--------------------------------------------------------------------
-	FX_BOOL Init(CFX_DIBitmap* pDevice, int Left, int Top);
+	bool Init(CFX_DIBitmap* pDevice, int Left, int Top);
 	CFX_DIBitmap* m_pDevice;
 	int m_Left;
 	int m_Top;
diff --git a/core/src/fxge/skia/fx_skia_device.cpp b/core/src/fxge/skia/fx_skia_device.cpp
index 41ce077976..72478b1097 100644
--- a/core/src/fxge/skia/fx_skia_device.cpp
+++ b/core/src/fxge/skia/fx_skia_device.cpp
@@ -46,24 +46,24 @@ class SuperBlitter_skia
 public:
 	static void DrawPath(const SkPath& srcPath, SkBlitter* blitter,  const SkRasterClip& rect, const SkPaint& origPaint);
 };
-FX_BOOL FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
+bool FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
 	if (SkPaint::kStroke_Style != paint.getStyle())
-		return FALSE;
+		return false;
 	FXSYS_assert(coverage);
 	SkScalar strokeWidth = paint.getStrokeWidth();
 	if (0 == strokeWidth) {
 		*coverage = SK_Scalar1;
-		return TRUE;
+		return true;
 	}
 	// if we get here, we need to try to fake a thick-stroke with a modulated
 	// hairline
 	if (!paint.isAntiAlias())
-		return FALSE;
+		return false;
 	if (strokeWidth <= SK_Scalar1) {
 		*coverage = strokeWidth;
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
 void SuperBlitter_skia::DrawPath(const SkPath& srcPath, SkBlitter* blitter, const SkRasterClip& rect, const SkPaint& origPaint)
@@ -167,7 +167,7 @@ void CSkia_PathData::BuildPath(const CFX_PathData* pPathData, const CFX_AffineMa
 static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path_data,
 					 const CFX_AffineMatrix* pObject2Device,
 					 const CFX_GraphStateData* pGraphState, FX_FIXFLOAT scale = FIX8_ONE,
-					 FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE)
+					 bool bStrokeAdjust = false, bool bTextMode = false)
 {
 	SkPaint::Cap cap;
 	switch (pGraphState->m_LineCap) {
@@ -203,7 +203,7 @@ static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path
 		stroker.setJoin(join);
 		stroker.setMiterLimit(pGraphState->m_MiterLimit);
 		stroker.setWidth(width);
-		stroker.setDoFill(FALSE);
+		stroker.setDoFill(false);
 		stroker.strokePath(path_data, dstPathData);
 		SkMatrix smatrix;
 		smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1);
@@ -235,7 +235,7 @@ static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path
 	}
 }
 
-CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
 	m_pAggDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
 }
@@ -243,7 +243,7 @@ CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver()
 {
     delete m_pAggDriver;
 }
-FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+bool CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
 		CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FIXFLOAT font_size, FX_DWORD color,
 		int alpha_flag, void* pIccTransform)
 {
@@ -259,7 +259,7 @@ void CFX_SkiaDeviceDriver::SaveState()
 	m_pAggDriver->SaveState();
 }
 
-void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved)
+void CFX_SkiaDeviceDriver::RestoreState(bool bKeepSaved)
 {
 	m_pAggDriver->RestoreState(bKeepSaved);
 }
@@ -294,7 +294,7 @@ void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint)
 	m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop, mask);
 
 }
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,	// path info
+bool CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,	// path info
 						const CFX_AffineMatrix* pObject2Device,	// optional transformation
 						int fill_mode	// fill mode, WINDING or ALTERNATE
 						)
@@ -308,7 +308,7 @@ FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,	//
 			rectf.Intersect(CFX_FloatRect(0, 0, (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
 			FX_RECT rect = rectf.GetOutterRect();
 			m_pAggDriver->m_pClipRgn->IntersectRect(rect);
-			return TRUE;
+			return true;
 		}
 	}
 	CSkia_PathData path_data;
@@ -318,15 +318,15 @@ FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,	//
 
 	SkPaint spaint;
 	spaint.setColor(0xffffffff);
-	spaint.setAntiAlias(TRUE);
+	spaint.setAntiAlias(true);
 	spaint.setStyle(SkPaint::kFill_Style);
 
 	SetClipMask(path_data.m_PathData, &spaint);
 
-	return TRUE;
+	return true;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,	// path info
+bool CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,	// path info
 						const CFX_AffineMatrix* pObject2Device,	// optional transformation
 						const CFX_GraphStateData* pGraphState	// graphic state, for pen attributes
 					)
@@ -342,36 +342,36 @@ FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
 	SkPaint spaint;
 	spaint.setColor(0xffffffff);
 	spaint.setStyle(SkPaint::kStroke_Style);
-	spaint.setAntiAlias(TRUE);
+	spaint.setAntiAlias(true);
 
 	SkPath dst_path;
-	SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device, pGraphState, 1, FALSE, 0);
+	SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device, pGraphState, 1, false, 0);
 	spaint.setStyle(SkPaint::kFill_Style);
 	SetClipMask(dst_path, &spaint);
 
-	return TRUE;
+	return true;
 }
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
+bool CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
 											  int alpha_flag, void* pIccTransform)
 {
 	return m_pAggDriver->RenderRasterizer(rasterizer, color, bFullCover, bGroupKnockout,alpha_flag, pIccTransform);
 }
-FX_BOOL	CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
-							int alpha_flag, void* pIccTransform, FX_BOOL bFill)
+bool	CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
+							int alpha_flag, void* pIccTransform, bool bFill)
 {
 	CFX_DIBitmap* pt = bGroupKnockout?m_pAggDriver->GetBackDrop():NULL;
 	CFX_SkiaRenderer render;
 	if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn, color, bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag, pIccTransform))
-		return FALSE;
+		return false;
 
 	SkRasterClip rasterClip(rect);
 	SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render,  rasterClip, origPaint);
 
-	return TRUE;
+	return true;
 
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,	// path info
+bool	CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,	// path info
 						const CFX_AffineMatrix* pObject2Device,	// optional transformation
 						const CFX_GraphStateData* pGraphState,	// graphic state, for pen attributes
 						FX_DWORD fill_color,			// fill color
@@ -381,7 +381,7 @@ FX_BOOL	CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,	// path in
 						void* pIccTransform
 						)
 {
-	if (GetBuffer() == NULL) return TRUE;
+	if (GetBuffer() == NULL) return true;
 	FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering");
 	SkIRect rect;
 	rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
@@ -396,11 +396,11 @@ FX_BOOL	CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,	// path in
 		path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType);
 
 		SkPaint spaint;
-		spaint.setAntiAlias(TRUE);
+		spaint.setAntiAlias(true);
 		spaint.setStyle(SkPaint::kFill_Style);
 		spaint.setColor(fill_color);
-		if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fill_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform))
-			return FALSE;
+		if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fill_color, fill_mode & FXFILL_FULLCOVER, false, alpha_flag, pIccTransform))
+			return false;
 	}
 
 	int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color);
@@ -427,48 +427,48 @@ FX_BOOL	CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,	// path in
 		SkPaint spaint;
 		spaint.setColor(stroke_color);
 		spaint.setStyle(SkPaint::kStroke_Style);
-		spaint.setAntiAlias(TRUE);
+		spaint.setAntiAlias(true);
 		SkPath dst_path;
-		SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, 0);
+		SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, false, 0);
 		spaint.setStyle(SkPaint::kFill_Style);
 		int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag)<<8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
 
-		if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color, fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag, pIccTransform, FALSE))
-			return FALSE;
+		if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color, fill_mode & FXFILL_FULLCOVER, false, fill_flag, pIccTransform, false))
+			return false;
 
 	}
 
-	return TRUE;
+	return true;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color,
+bool CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color,
 						int alpha_flag, void* pIccTransform)
 {
 	return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform)
+bool CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform)
 {
 	return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect)
+bool CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect)
 {
 	return m_pAggDriver->GetClipBox(pRect);
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
+bool	CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, bool bDEdge)
 {
 	return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge);
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool	CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
 									   int alpha_flag, void* pIccTransform)
 {
 	return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend_type, alpha_flag, pIccTransform);
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
+bool	CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
 							int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
 							int alpha_flag, void* pIccTransform)
 {
@@ -477,7 +477,7 @@ FX_BOOL	CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWO
 							alpha_flag, pIccTransform);
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
+bool	CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
 						const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
 						int alpha_flag, void* pIccTransform)
 {
@@ -485,7 +485,7 @@ FX_BOOL	CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitm
 						pMatrix, render_flags, handle, alpha_flag, pIccTransform);
 }
 
-FX_BOOL	CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
+bool	CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
 {
 	return m_pAggDriver->ContinueDIBits(pHandle, pPause);
 }
@@ -497,31 +497,31 @@ void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle)
 
 CFX_SkiaDevice::CFX_SkiaDevice()
 {
-	m_bOwnedBitmap = FALSE;
+	m_bOwnedBitmap = false;
 }
 
-FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+bool CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
 	if (pBitmap == NULL)
-		return FALSE;
+		return false;
 	SetBitmap(pBitmap);
 	CFX_SkiaDeviceDriver* pDriver = new CFX_SkiaDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
 	SetDeviceDriver(pDriver);
-	return TRUE;
+	return true;
 }
 
-FX_BOOL CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
+bool CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
 {
-	m_bOwnedBitmap = TRUE;
+	m_bOwnedBitmap = true;
 	CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
 	if (!pBitmap->Create(width, height, format)) {
 		delete pBitmap;
-		return FALSE;
+		return false;
 	}
 	SetBitmap(pBitmap);
-	CFX_SkiaDeviceDriver* pDriver =  new CFX_SkiaDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
+	CFX_SkiaDeviceDriver* pDriver =  new CFX_SkiaDeviceDriver(pBitmap, dither_bits, false, pOriDevice, false);
 	SetDeviceDriver(pDriver);
-	return TRUE;
+	return true;
 }
 CFX_SkiaDevice::~CFX_SkiaDevice()
 {
diff --git a/core/src/fxge/skia/fx_skia_device.h b/core/src/fxge/skia/fx_skia_device.h
index ab51e51a33..7278671dc7 100644
--- a/core/src/fxge/skia/fx_skia_device.h
+++ b/core/src/fxge/skia/fx_skia_device.h
@@ -9,7 +9,7 @@
 class CFX_SkiaDeviceDriver : public IFX_RenderDeviceDriver
 {
 public:
-	CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout);
+	CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout);
 	virtual ~CFX_SkiaDeviceDriver();
 
 	/** Options */
@@ -17,22 +17,22 @@ public:
 
 	/** Save and restore all graphic states */
 	virtual void		SaveState();
-	virtual void		RestoreState(FX_BOOL bKeepSaved);
+	virtual void		RestoreState(bool bKeepSaved);
 
 	/** Set clipping path using filled region */
-	virtual FX_BOOL		SetClip_PathFill(const CFX_PathData* pPathData,	// path info
+	virtual bool		SetClip_PathFill(const CFX_PathData* pPathData,	// path info
 							const CFX_AffineMatrix* pObject2Device,	// optional transformation
 							int fill_mode	// fill mode, WINDING or ALTERNATE
 							);
 
 	/** Set clipping path using stroked region */
-	virtual FX_BOOL		SetClip_PathStroke(const CFX_PathData* pPathData,	// path info
+	virtual bool		SetClip_PathStroke(const CFX_PathData* pPathData,	// path info
 							const CFX_AffineMatrix* pObject2Device,	// optional transformation
 							const CFX_GraphStateData* pGraphState	// graphic state, for pen attributes
 							);
 
 	/** Draw a path */
-	virtual FX_BOOL		DrawPath(const CFX_PathData* pPathData,
+	virtual bool		DrawPath(const CFX_PathData* pPathData,
 						const CFX_AffineMatrix* pObject2Device,
 						const CFX_GraphStateData* pGraphState,
 						FX_DWORD fill_color,
@@ -42,44 +42,44 @@ public:
 						void* pIccTransform = NULL
 							);
 
-	virtual FX_BOOL		SetPixel(int x, int y, FX_DWORD color,
+	virtual bool		SetPixel(int x, int y, FX_DWORD color,
 						int alpha_flag = 0, void* pIccTransform = NULL);
 
-	virtual FX_BOOL		FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
+	virtual bool		FillRect(const FX_RECT* pRect, FX_DWORD fill_color,
 						int alpha_flag = 0, void* pIccTransform = NULL);
 
 	/** Draw a single pixel (device dependant) line */
-	virtual FX_BOOL		DrawCosmeticLine(FX_FIXFLOAT x1, FX_FIXFLOAT y1, FX_FIXFLOAT x2, FX_FIXFLOAT y2, FX_DWORD color,
-							int alpha_flag, void* pIccTransform, int blend_type) { return FALSE; }
+	virtual bool		DrawCosmeticLine(FX_FIXFLOAT x1, FX_FIXFLOAT y1, FX_FIXFLOAT x2, FX_FIXFLOAT y2, FX_DWORD color,
+							int alpha_flag, void* pIccTransform, int blend_type) { return false; }
 
-	virtual FX_BOOL		GetClipBox(FX_RECT* pRect);
+	virtual bool		GetClipBox(FX_RECT* pRect);
 
 	/** Load device buffer into a DIB */
-	virtual FX_BOOL		GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, FX_BOOL bDEdge = FALSE);
+	virtual bool		GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, bool bDEdge = false);
 
 	virtual CFX_DIBitmap*   GetBackDrop() { return m_pAggDriver->GetBackDrop(); }
 
-	virtual FX_BOOL		SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect,
+	virtual bool		SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect,
 						int dest_left, int dest_top, int blend_type,
 						int alpha_flag = 0, void* pIccTransform = NULL);
-	virtual FX_BOOL		StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+	virtual bool		StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
 				int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
 				int alpha_flag = 0, void* pIccTransform = NULL);
 
-	virtual FX_BOOL		StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+	virtual bool		StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
 				const CFX_AffineMatrix* pMatrix, FX_DWORD flags, void*& handle,
 				int alpha_flag = 0, void* pIccTransform = NULL);
-	virtual FX_BOOL		ContinueDIBits(void* handle, IFX_Pause* pPause);
+	virtual bool		ContinueDIBits(void* handle, IFX_Pause* pPause);
 	virtual void		CancelDIBits(void* handle);
 
-	virtual FX_BOOL     DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+	virtual bool     DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
 						CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FIXFLOAT font_size, FX_DWORD color,
 						int alpha_flag = 0, void* pIccTransform = NULL);
 
-	virtual FX_BOOL		RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
+	virtual bool		RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
 							int alpha_flag, void* pIccTransform);
-	virtual FX_BOOL		RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
-							int alpha_flag, void* pIccTransform, FX_BOOL bFill = TRUE);
+	virtual bool		RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
+							int alpha_flag, void* pIccTransform, bool bFill = true);
 	void				SetClipMask(rasterizer_scanline_aa& rasterizer);
 	void				SetClipMask(SkPath& skPath, SkPaint* spaint);
 	virtual	uint8_t*	GetBuffer() const {return m_pAggDriver->GetBuffer();}
diff --git a/core/src/fxge/win32/dwrite_int.h b/core/src/fxge/win32/dwrite_int.h
index dc2a338935..4896161547 100644
--- a/core/src/fxge/win32/dwrite_int.h
+++ b/core/src/fxge/win32/dwrite_int.h
@@ -35,15 +35,15 @@ public:
     void			Load();
     void            Unload();
 
-    FX_BOOL			IsAvailable()
+    bool			IsAvailable()
     {
         return m_pDWriteFactory != NULL;
     }
 
     void*			DwCreateFontFaceFromStream(uint8_t* pData, FX_DWORD size, int simulation_style);
-    FX_BOOL         DwCreateRenderingTarget(CFX_DIBitmap* pSrc, void** renderTarget);
+    bool         DwCreateRenderingTarget(CFX_DIBitmap* pSrc, void** renderTarget);
     void            DwDeleteRenderingTarget(void* renderTarget);
-    FX_BOOL			DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, FX_RECT& stringRect, CFX_AffineMatrix* pMatrix,
+    bool			DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, FX_RECT& stringRect, CFX_AffineMatrix* pMatrix,
                                     void *font, FX_FLOAT font_size, FX_ARGB text_color,
                                     int glyph_count, unsigned short* glyph_indices,
                                     FX_FLOAT baselineOriginX, FX_FLOAT baselineOriginY,
diff --git a/core/src/fxge/win32/fx_win32_device.cpp b/core/src/fxge/win32/fx_win32_device.cpp
index 18bcc595a4..e6667b17ec 100644
--- a/core/src/fxge/win32/fx_win32_device.cpp
+++ b/core/src/fxge/win32/fx_win32_device.cpp
@@ -24,18 +24,18 @@ public:
     CWin32FontInfo();
     ~CWin32FontInfo();
     virtual void		Release();
-    virtual	FX_BOOL		EnumFontList(CFX_FontMapper* pMapper);
-    virtual void*		MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* face, FX_BOOL& bExact);
+    virtual	bool		EnumFontList(CFX_FontMapper* pMapper);
+    virtual void*		MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* face, bool& bExact);
     virtual void*		GetFont(const FX_CHAR* face)
     {
         return NULL;
     }
     virtual FX_DWORD	GetFontData(void* hFont, FX_DWORD table, uint8_t* buffer, FX_DWORD size);
     virtual void		DeleteFont(void* hFont);
-    virtual	FX_BOOL		GetFaceName(void* hFont, CFX_ByteString& name);
-    virtual FX_BOOL		GetFontCharset(void* hFont, int& charset);
-    FX_BOOL				IsOpenTypeFromDiv(const LOGFONTA *plf);
-    FX_BOOL				IsSupportFontFormDiv(const LOGFONTA* plf);
+    virtual	bool		GetFaceName(void* hFont, CFX_ByteString& name);
+    virtual bool		GetFontCharset(void* hFont, int& charset);
+    bool				IsOpenTypeFromDiv(const LOGFONTA *plf);
+    bool				IsSupportFontFormDiv(const LOGFONTA* plf);
     void				AddInstalledFont(const LOGFONTA *plf, FX_DWORD FontType);
     void				GetGBPreference(CFX_ByteString& face, int weight, int picth_family);
     void				GetJapanesePreference(CFX_ByteString& face, int weight, int picth_family);
@@ -59,10 +59,10 @@ void CWin32FontInfo::Release()
     delete this;
 }
 #define TT_MAKE_TAG(x1, x2, x3, x4) (((FX_DWORD)x1<<24)|((FX_DWORD)x2<<16)|((FX_DWORD)x3<<8)|(FX_DWORD)x4)
-FX_BOOL CWin32FontInfo::IsOpenTypeFromDiv(const LOGFONTA *plf)
+bool CWin32FontInfo::IsOpenTypeFromDiv(const LOGFONTA *plf)
 {
     HFONT hFont = CreateFontIndirectA(plf);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD font_size  = GetFontData(hFont, 0, NULL, 0);
     if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
         FX_DWORD lVersion = 0;
@@ -74,16 +74,16 @@ FX_BOOL CWin32FontInfo::IsOpenTypeFromDiv(const LOGFONTA *plf)
                 lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
                 lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') ||
                 lVersion == 0x00020000) {
-            ret = TRUE;
+            ret = true;
         }
     }
     DeleteFont(hFont);
     return ret;
 }
-FX_BOOL CWin32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf)
+bool CWin32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf)
 {
     HFONT hFont = CreateFontIndirectA(plf);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD font_size  = GetFontData(hFont, 0, NULL, 0);
     if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
         FX_DWORD lVersion = 0;
@@ -95,10 +95,10 @@ FX_BOOL CWin32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf)
                 lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
                 lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') ||
                 lVersion == 0x00020000) {
-            ret = TRUE;
+            ret = true;
         } else if ((lVersion & 0xFFFF0000) == TT_MAKE_TAG(0x80, 0x01, 0x00, 0x00) ||
                    (lVersion & 0xFFFF0000) == TT_MAKE_TAG('%', '!', 0, 0)) {
-            ret = TRUE;
+            ret = true;
         }
     }
     DeleteFont(hFont);
@@ -139,7 +139,7 @@ static int CALLBACK FontEnumProc(
     pFontInfo->AddInstalledFont(plf, FontType);
     return 1;
 }
-FX_BOOL CWin32FontInfo::EnumFontList(CFX_FontMapper* pMapper)
+bool CWin32FontInfo::EnumFontList(CFX_FontMapper* pMapper)
 {
     m_pMapper = pMapper;
     LOGFONTA lf;
@@ -151,7 +151,7 @@ FX_BOOL CWin32FontInfo::EnumFontList(CFX_FontMapper* pMapper)
     if (pMapper->GetFontEnumerator()) {
         pMapper->GetFontEnumerator()->Finish();
     }
-    return TRUE;
+    return true;
 }
 static const struct {
     const FX_CHAR*	m_pFaceName;
@@ -163,22 +163,22 @@ VariantNames[] = {
 static const struct {
     const FX_CHAR*	m_pName;
     const FX_CHAR*	m_pWinName;
-    FX_BOOL		m_bBold;
-    FX_BOOL		m_bItalic;
+    bool		m_bBold;
+    bool		m_bItalic;
 }
 Base14Substs[] = {
-    {"Courier", "Courier New", FALSE, FALSE},
-    {"Courier-Bold", "Courier New", TRUE, FALSE},
-    {"Courier-BoldOblique", "Courier New", TRUE, TRUE},
-    {"Courier-Oblique", "Courier New", FALSE, TRUE},
-    {"Helvetica", "Arial", FALSE, FALSE},
-    {"Helvetica-Bold", "Arial", TRUE, FALSE},
-    {"Helvetica-BoldOblique", "Arial", TRUE, TRUE},
-    {"Helvetica-Oblique", "Arial", FALSE, TRUE},
-    {"Times-Roman", "Times New Roman", FALSE, FALSE},
-    {"Times-Bold", "Times New Roman", TRUE, FALSE},
-    {"Times-BoldItalic", "Times New Roman", TRUE, TRUE},
-    {"Times-Italic", "Times New Roman", FALSE, TRUE},
+    {"Courier", "Courier New", false, false},
+    {"Courier-Bold", "Courier New", true, false},
+    {"Courier-BoldOblique", "Courier New", true, true},
+    {"Courier-Oblique", "Courier New", false, true},
+    {"Helvetica", "Arial", false, false},
+    {"Helvetica-Bold", "Arial", true, false},
+    {"Helvetica-BoldOblique", "Arial", true, true},
+    {"Helvetica-Oblique", "Arial", false, true},
+    {"Times-Roman", "Times New Roman", false, false},
+    {"Times-Bold", "Times New Roman", true, false},
+    {"Times-BoldItalic", "Times New Roman", true, true},
+    {"Times-Italic", "Times New Roman", false, true},
 };
 CFX_ByteString CWin32FontInfo::FindFont(const CFX_ByteString& name)
 {
@@ -212,17 +212,17 @@ extern "C" {
         return FXSYS_stricmp((const FX_CHAR*)key, ((_FontNameMap*)element)->m_pSrcFontName);
     }
 }
-FX_BOOL _GetSubFontName(CFX_ByteString& name)
+bool _GetSubFontName(CFX_ByteString& name)
 {
     int size = sizeof g_JpFontNameMap;
     void* pFontnameMap = (void*)g_JpFontNameMap;
     _FontNameMap* found = (_FontNameMap*)FXSYS_bsearch(name.c_str(), pFontnameMap,
                           size / sizeof (_FontNameMap), sizeof (_FontNameMap), compareString);
     if (found == NULL) {
-        return FALSE;
+        return false;
     }
     name = found->m_pSubFontName;
-    return TRUE;
+    return true;
 }
 void CWin32FontInfo::GetGBPreference(CFX_ByteString& face, int weight, int picth_family)
 {
@@ -285,7 +285,7 @@ void CWin32FontInfo::GetJapanesePreference(CFX_ByteString& face, int weight, int
         face = "MS PMincho";
     }
 }
-void* CWin32FontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, FX_BOOL& bExact)
+void* CWin32FontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, bool& bExact)
 {
     CFX_ByteString face = cstr_face;
     int iBaseFont;
@@ -294,7 +294,7 @@ void* CWin32FontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitc
             face = Base14Substs[iBaseFont].m_pWinName;
             weight = Base14Substs[iBaseFont].m_bBold ? FW_BOLD : FW_NORMAL;
             bItalic = Base14Substs[iBaseFont].m_bItalic;
-            bExact = TRUE;
+            bExact = true;
             break;
         }
     if (charset == ANSI_CHARSET || charset == SYMBOL_CHARSET) {
@@ -373,26 +373,26 @@ FX_DWORD CWin32FontInfo::GetFontData(void* hFont, FX_DWORD table, uint8_t* buffe
     }
     return size;
 }
-FX_BOOL CWin32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
+bool CWin32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
 {
     char facebuf[100];
     HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
     int ret = ::GetTextFaceA(m_hDC, 100, facebuf);
     ::SelectObject(m_hDC, hOldFont);
     if (ret == 0) {
-        return FALSE;
+        return false;
     }
     name = facebuf;
-    return TRUE;
+    return true;
 }
-FX_BOOL CWin32FontInfo::GetFontCharset(void* hFont, int& charset)
+bool CWin32FontInfo::GetFontCharset(void* hFont, int& charset)
 {
     TEXTMETRIC tm;
     HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
     ::GetTextMetrics(m_hDC, &tm);
     ::SelectObject(m_hDC, hOldFont);
     charset = tm.tmCharSet;
-    return TRUE;
+    return true;
 }
 IFX_SystemFontInfo* IFX_SystemFontInfo::CreateDefault()
 {
@@ -466,16 +466,16 @@ void* CGdiDeviceDriver::GetClipRgn()
     }
     return (void*)hClipRgn;
 }
-FX_BOOL CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_RECT* pSrcRect, int left, int top, void* pIccTransform)
+bool CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_RECT* pSrcRect, int left, int top, void* pIccTransform)
 {
     if (m_DeviceClass == FXDC_PRINTER) {
-        CFX_DIBitmap* pBitmap = pBitmap1->FlipImage(FALSE, TRUE);
+        CFX_DIBitmap* pBitmap = pBitmap1->FlipImage(false, true);
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         if ((pBitmap->IsCmykImage() || pIccTransform) &&
                 !pBitmap->ConvertFormat(FXDIB_Rgb, pIccTransform)) {
-            return FALSE;
+            return false;
         }
         int width = pSrcRect->Width(), height = pSrcRect->Height();
         int pitch = pBitmap->GetPitch();
@@ -493,7 +493,7 @@ FX_BOOL CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_R
         CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
         if ((pBitmap->IsCmykImage() || pIccTransform) &&
                 (pBitmap = pBitmap->CloneConvert(FXDIB_Rgb, NULL, pIccTransform)) == NULL) {
-            return FALSE;
+            return false;
         }
         int width = pSrcRect->Width(), height = pSrcRect->Height();
         int pitch = pBitmap->GetPitch();
@@ -505,18 +505,18 @@ FX_BOOL CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_R
             delete pBitmap;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
+bool CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
         int dest_width, int dest_height, FX_DWORD flags, void* pIccTransform)
 {
     CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
     if (pBitmap == NULL || dest_width == 0  || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     if ((pBitmap->IsCmykImage() || pIccTransform) &&
             !pBitmap->ConvertFormat(FXDIB_Rgb, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
     if ((int64_t)abs(dest_width) * abs(dest_height) < (int64_t)pBitmap1->GetWidth() * pBitmap1->GetHeight() * 4 ||
@@ -538,15 +538,15 @@ FX_BOOL CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1, int de
     if (del) {
         delete pToStrechBitmap;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
+bool CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
         int dest_width, int dest_height, FX_DWORD bitmap_color, FX_DWORD flags,
         int alpha_flag, void* pIccTransform)
 {
     CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
     if (pBitmap == NULL || dest_width == 0  || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(bitmap_color, bitmap_color, alpha_flag | (1 << 24), pIccTransform);
     int width = pBitmap->GetWidth(), height = pBitmap->GetHeight();
@@ -592,16 +592,16 @@ FX_BOOL CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1, int d
     SelectObject(m_hDC, hOld);
     DeleteObject(hPattern);
 
-    return TRUE;
+    return true;
 }
 BOOL CGdiDeviceDriver::GetClipBox(FX_RECT* pRect)
 {
     return ::GetClipBox(m_hDC, (RECT*)pRect);
 }
-FX_BOOL CGdiDeviceDriver::SetClipRgn(void* hRgn)
+bool CGdiDeviceDriver::SetClipRgn(void* hRgn)
 {
     ::SelectClipRgn(m_hDC, (HRGN)hRgn);
-    return TRUE;
+    return true;
 }
 static HPEN _CreatePen(const CFX_GraphStateData* pGraphState, const CFX_AffineMatrix* pMatrix, FX_DWORD argb)
 {
@@ -749,11 +749,11 @@ void CGdiDeviceDriver::DrawLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT
     MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), NULL);
     LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
 }
-static FX_BOOL _MatrixNoScaled(const CFX_AffineMatrix* pMatrix)
+static bool _MatrixNoScaled(const CFX_AffineMatrix* pMatrix)
 {
     return pMatrix->GetA() == 1.0f && pMatrix->GetB() == 0 && pMatrix->GetC() == 0 && pMatrix->GetD() == 1.0f;
 }
-FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_AffineMatrix* pMatrix,
                                    const CFX_GraphStateData* pGraphState,
                                    FX_DWORD fill_color,
@@ -765,7 +765,7 @@ FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                   )
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
     _Color2Argb(stroke_color, stroke_color, alpha_flag, pIccTransform);
@@ -786,9 +786,9 @@ FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
     }
     int fill_alpha = FXARGB_A(fill_color);
     int stroke_alpha = FXARGB_A(stroke_color);
-    FX_BOOL bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) || (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
+    bool bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) || (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
     if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha) {
-        return FALSE;
+        return false;
     }
     if (pPlatform->m_GdiplusExt.IsAvailable()) {
         if (bDrawAlpha || ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) || (pGraphState && pGraphState->m_DashCount))) {
@@ -797,7 +797,7 @@ FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                     (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) &&
                     pPathData->IsRect()) ) {
                 if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix, pGraphState, fill_color, stroke_color, fill_mode)) {
-                    return TRUE;
+                    return true;
                 }
             }
         }
@@ -852,29 +852,29 @@ FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
         hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
         DeleteObject(hBrush);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
+bool CGdiDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
     int alpha;
     FX_COLORREF rgb;
     ArgbDecode(fill_color, alpha, rgb);
     if (alpha == 0) {
-        return TRUE;
+        return true;
     }
     if (alpha < 255) {
-        return FALSE;
+        return false;
     }
     HBRUSH hBrush = CreateSolidBrush(rgb);
     ::FillRect(m_hDC, (RECT*)pRect, hBrush);
     DeleteObject(hBrush);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pMatrix,
         int fill_mode
                                           )
@@ -884,15 +884,15 @@ FX_BOOL CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
         if (pPathData->IsRect(pMatrix, &rectf)) {
             FX_RECT rect = rectf.GetOutterRect();
             IntersectClipRect(m_hDC, rect.left, rect.top, rect.right, rect.bottom);
-            return TRUE;
+            return true;
         }
     }
     _SetPathToDC(m_hDC, pPathData, pMatrix);
     SetPolyFillMode(m_hDC, fill_mode & 3);
     SelectClipPath(m_hDC, RGN_AND);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pMatrix,
         const CFX_GraphStateData* pGraphState
                                             )
@@ -902,23 +902,23 @@ FX_BOOL CGdiDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
     _SetPathToDC(m_hDC, pPathData, pMatrix);
     WidenPath(m_hDC);
     SetPolyFillMode(m_hDC, WINDING);
-    FX_BOOL ret = SelectClipPath(m_hDC, RGN_AND);
+    bool ret = SelectClipPath(m_hDC, RGN_AND);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
     return ret;
 }
-FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+bool CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
         int alpha_flag, void* pIccTransform, int	blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(color, color, alpha_flag | (1 << 24), pIccTransform);
     int a;
     FX_COLORREF rgb;
     ArgbDecode(color, a, rgb);
     if (a == 0) {
-        return TRUE;
+        return true;
     }
     HPEN hPen = CreatePen(PS_SOLID, 1, rgb);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
@@ -926,12 +926,12 @@ FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2
     LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::DeleteDeviceRgn(void* pRgn)
+bool CGdiDeviceDriver::DeleteDeviceRgn(void* pRgn)
 {
     DeleteObject((HGDIOBJ)pRgn);
-    return TRUE;
+    return true;
 }
 CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC) : CGdiDeviceDriver(hDC, FXDC_DISPLAY)
 {
@@ -940,9 +940,9 @@ CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC) : CGdiDeviceDriver(hDC, FXDC_DISPL
         m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE;
     }
 }
-FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
+bool CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, bool bDEdge)
 {
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     int width = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height);
@@ -969,7 +969,7 @@ FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, v
             ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap.GetBuffer(), &bmi, DIB_RGB_COLORS);
             ret = pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0, pIccTransform);
         } else {
-            ret = FALSE;
+            ret = false;
         }
     }
     if (pBitmap->HasAlpha() && ret) {
@@ -979,22 +979,22 @@ FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, v
     DeleteObject(hDCMemory);
     return ret;
 }
-FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                      int alpha_flag, void* pIccTransform)
 {
     ASSERT(blend_type == FXDIB_BLEND_NORMAL);
     if (pSource->IsAlphaMask()) {
         int width = pSource->GetWidth(), height = pSource->GetHeight();
         int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
-        FX_BOOL bGDI = pSource->GetBPP() == 1 && alpha == 255;
+        bool bGDI = pSource->GetBPP() == 1 && alpha == 255;
         if (!bGDI) {
             CFX_DIBitmap background;
             if (!background.Create(width, height, FXDIB_Rgb32) ||
                 !GetDIBits(&background, left, top, NULL) ||
                 !background.CompositeMask(0, 0, width, height, pSource, color,
-                                          0, 0, FXDIB_BLEND_NORMAL, NULL, FALSE,
+                                          0, 0, FXDIB_BLEND_NORMAL, NULL, false,
                                           alpha_flag, pIccTransform)) {
-                return FALSE;
+                return false;
             }
             FX_RECT src_rect(0, 0, width, height);
             return SetDIBits(&background, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL, 0, NULL);
@@ -1008,8 +1008,8 @@ FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD colo
         CFX_DIBitmap bitmap;
         if (!bitmap.Create(width, height, FXDIB_Rgb) ||
             !GetDIBits(&bitmap, left, top, NULL) ||
-            !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left, pSrcRect->top, FXDIB_BLEND_NORMAL, NULL, FALSE, pIccTransform)) {
-            return FALSE;
+            !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left, pSrcRect->top, FXDIB_BLEND_NORMAL, NULL, false, pIccTransform)) {
+            return false;
         }
         FX_RECT src_rect(0, 0, width, height);
         return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL, 0, NULL);
@@ -1019,9 +1019,9 @@ FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD colo
     if (pBitmap) {
         return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, int render_flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
@@ -1035,14 +1035,14 @@ FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource, F
     bitmap_clip.Offset(-dest_left, -dest_top);
     CFX_DIBitmap* pStretched = pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip);
     if (pStretched == NULL) {
-        return TRUE;
+        return true;
     }
     FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
-    FX_BOOL ret = SetDIBits(pStretched, color, &src_rect, pClipRect->left, pClipRect->top, FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
+    bool ret = SetDIBits(pStretched, color, &src_rect, pClipRect->left, pClipRect->top, FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
     delete pStretched;
     return ret;
 }
-FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
@@ -1063,17 +1063,17 @@ FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD
         int clip_width = clip_rect.Width(), clip_height = clip_rect.Height();
         CFX_DIBitmap* pStretched = pSource->StretchTo(dest_width, dest_height, flags, &clip_rect);
         if (pStretched == NULL) {
-            return TRUE;
+            return true;
         }
         CFX_DIBitmap background;
         if (!background.Create(clip_width, clip_height, FXDIB_Rgb32) ||
             !GetDIBits(&background, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, NULL) ||
-            !background.CompositeMask(0, 0, clip_width, clip_height, pStretched, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, FALSE, alpha_flag, pIccTransform)) {
+            !background.CompositeMask(0, 0, clip_width, clip_height, pStretched, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, false, alpha_flag, pIccTransform)) {
             delete pStretched;
-            return FALSE;
+            return false;
         }
         FX_RECT src_rect(0, 0, clip_width, clip_height);
-        FX_BOOL ret = SetDIBits(&background, 0, &src_rect, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL, 0, NULL);
+        bool ret = SetDIBits(&background, 0, &src_rect, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL, 0, NULL);
         delete pStretched;
         return ret;
     }
@@ -1083,7 +1083,7 @@ FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD
             CFX_DIBExtractor temp(pSource);
             CFX_DIBitmap* pBitmap = temp;
             if (pBitmap == NULL) {
-                return FALSE;
+                return false;
             }
             return pPlatform->m_GdiplusExt.StretchDIBits(m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height, pClipRect, flags);
         }
@@ -1095,7 +1095,7 @@ FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD
     if (pBitmap) {
         return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width, dest_height, flags, pIccTransform);
     }
-    return FALSE;
+    return false;
 }
 #define GET_PS_FEATURESETTING        4121
 #define FEATURESETTING_PSLEVEL       2
@@ -1134,7 +1134,7 @@ int GetPSLevel(HDC hDC)
     return 2;
 }
 int CFX_WindowsDevice::m_psLevel = 2;
-CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC, FX_BOOL bCmykOutput, FX_BOOL bForcePSOutput, int psLevel)
+CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC, bool bCmykOutput, bool bForcePSOutput, int psLevel)
 {
     m_bForcePSOutput = bForcePSOutput;
     m_psLevel = psLevel;
@@ -1154,7 +1154,7 @@ HDC CFX_WindowsDevice::GetDC() const
     }
     return (HDC)pRDD->GetPlatformSurface();
 }
-IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC, FX_BOOL bCmykOutput)
+IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC, bool bCmykOutput)
 {
     int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
     int obj_type = ::GetObjectType(hDC);
diff --git a/core/src/fxge/win32/fx_win32_dib.cpp b/core/src/fxge/win32/fx_win32_dib.cpp
index 3dcfce4802..610c69e4b1 100644
--- a/core/src/fxge/win32/fx_win32_dib.cpp
+++ b/core/src/fxge/win32/fx_win32_dib.cpp
@@ -49,19 +49,19 @@ CFX_ByteString CFX_WindowsDIB::GetBitmapInfo(const CFX_DIBitmap* pBitmap)
     result.ReleaseBuffer(len);
     return result;
 }
-CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData, FX_BOOL bAlpha)
+CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData, bool bAlpha)
 {
     int width = pbmi->bmiHeader.biWidth;
     int height = pbmi->bmiHeader.biHeight;
-    BOOL bBottomUp = TRUE;
+    BOOL bBottomUp = true;
     if (height < 0) {
         height = -height;
-        bBottomUp = FALSE;
+        bBottomUp = false;
     }
     int pitch = (width * pbmi->bmiHeader.biBitCount + 31) / 32 * 4;
     CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
     FXDIB_Format format = bAlpha ? (FXDIB_Format)(pbmi->bmiHeader.biBitCount + 0x200) : (FXDIB_Format)pbmi->bmiHeader.biBitCount;
-    FX_BOOL ret = pBitmap->Create(width, height, format);
+    bool ret = pBitmap->Create(width, height, format);
     if (!ret) {
         delete pBitmap;
         return NULL;
@@ -93,7 +93,7 @@ CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData, FX_BOOL
 }
 CFX_DIBitmap* CFX_WindowsDIB::LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData)
 {
-    return _FX_WindowsDIB_LoadFromBuf(pbmi, pData, FALSE);
+    return _FX_WindowsDIB_LoadFromBuf(pbmi, pData, false);
 }
 HBITMAP	CFX_WindowsDIB::GetDDBitmap(const CFX_DIBitmap* pBitmap, HDC hDC)
 {
@@ -174,7 +174,7 @@ CFX_DIBitmap* CFX_WindowsDIB::LoadDIBitmap(WINDIB_Open_Args_ args)
 }
 CFX_DIBitmap* CFX_WindowsDIB::LoadFromDDB(HDC hDC, HBITMAP hBitmap, FX_DWORD* pPalette, FX_DWORD palsize)
 {
-    FX_BOOL bCreatedDC = hDC == NULL;
+    bool bCreatedDC = hDC == NULL;
     if (hDC == NULL) {
         hDC = CreateCompatibleDC(NULL);
     }
diff --git a/core/src/fxge/win32/fx_win32_dwrite.cpp b/core/src/fxge/win32/fx_win32_dwrite.cpp
index 65a35d86a1..8533343926 100644
--- a/core/src/fxge/win32/fx_win32_dwrite.cpp
+++ b/core/src/fxge/win32/fx_win32_dwrite.cpp
@@ -133,7 +133,7 @@ LPVOID	CDWriteExt::DwCreateFontFaceFromStream(uint8_t* pData, FX_DWORD size, int
     IDWriteFactory* pDwFactory = (IDWriteFactory*)m_pDWriteFactory;
     IDWriteFontFile* pDwFontFile = NULL;
     IDWriteFontFace* pDwFontFace = NULL;
-    BOOL isSupportedFontType = FALSE;
+    BOOL isSupportedFontType = false;
     DWRITE_FONT_FILE_TYPE fontFileType;
     DWRITE_FONT_FACE_TYPE fontFaceType;
     UINT32 numberOfFaces;
@@ -174,10 +174,10 @@ failed:
     SafeRelease(&pDwFontFile);
     return NULL;
 }
-FX_BOOL CDWriteExt::DwCreateRenderingTarget(CFX_DIBitmap* pBitmap, void** renderTarget)
+bool CDWriteExt::DwCreateRenderingTarget(CFX_DIBitmap* pBitmap, void** renderTarget)
 {
     if (pBitmap->GetFormat() > FXDIB_Argb) {
-        return FALSE;
+        return false;
     }
     IDWriteFactory* pDwFactory = (IDWriteFactory*)m_pDWriteFactory;
     IDWriteGdiInterop* pGdiInterop = NULL;
@@ -212,14 +212,14 @@ FX_BOOL CDWriteExt::DwCreateRenderingTarget(CFX_DIBitmap* pBitmap, void** render
     SafeRelease(&pGdiInterop);
     SafeRelease(&pBitmapRenderTarget);
     SafeRelease(&pRenderingParams);
-    return TRUE;
+    return true;
 failed:
     SafeRelease(&pGdiInterop);
     SafeRelease(&pBitmapRenderTarget);
     SafeRelease(&pRenderingParams);
-    return FALSE;
+    return false;
 }
-FX_BOOL	CDWriteExt::DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, FX_RECT& stringRect, CFX_AffineMatrix* pMatrix,
+bool	CDWriteExt::DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, FX_RECT& stringRect, CFX_AffineMatrix* pMatrix,
                                     void *font, FX_FLOAT font_size, FX_ARGB text_color,
                                     int glyph_count, unsigned short* glyph_indices,
                                     FX_FLOAT baselineOriginX, FX_FLOAT baselineOriginY,
@@ -227,7 +227,7 @@ FX_BOOL	CDWriteExt::DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, F
                                     FX_FLOAT* glyph_advances)
 {
     if (renderTarget == NULL) {
-        return TRUE;
+        return true;
     }
     CDwGdiTextRenderer* pTextRenderer = (CDwGdiTextRenderer*)renderTarget;
     DWRITE_MATRIX transform;
@@ -247,7 +247,7 @@ FX_BOOL	CDWriteExt::DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, F
     glyphRun.glyphIndices = glyph_indices;
     glyphRun.glyphAdvances = glyph_advances;
     glyphRun.glyphOffsets = (DWRITE_GLYPH_OFFSET*)glyph_offsets;
-    glyphRun.isSideways = FALSE;
+    glyphRun.isSideways = false;
     glyphRun.bidiLevel = 0;
     hr = pTextRenderer->DrawGlyphRun(
              stringRect,
@@ -258,7 +258,7 @@ FX_BOOL	CDWriteExt::DwRendingString(void* renderTarget, CFX_ClipRgn* pClipRgn, F
              &glyphRun,
              RGB(FXARGB_R(text_color), FXARGB_G(text_color), FXARGB_B(text_color))
          );
-    return SUCCEEDED(hr) ? TRUE : FALSE;
+    return SUCCEEDED(hr) ? true : false;
 }
 void CDWriteExt::DwDeleteRenderingTarget(void* renderTarget)
 {
diff --git a/core/src/fxge/win32/fx_win32_gdipext.cpp b/core/src/fxge/win32/fx_win32_gdipext.cpp
index d76d52e50b..94fac69157 100644
--- a/core/src/fxge/win32/fx_win32_gdipext.cpp
+++ b/core/src/fxge/win32/fx_win32_gdipext.cpp
@@ -274,12 +274,12 @@ void* CGdiplusExt::GdiAddFontMemResourceEx(void *pFontdata, FX_DWORD size, void*
     }
     return NULL;
 }
-FX_BOOL CGdiplusExt::GdiRemoveFontMemResourceEx(void* handle)
+bool CGdiplusExt::GdiRemoveFontMemResourceEx(void* handle)
 {
     if (m_pGdiRemoveFontMemResourseEx) {
         return ((FuncType_GdiRemoveFontMemResourceEx)m_pGdiRemoveFontMemResourseEx)((HANDLE)handle);
     }
-    return FALSE;
+    return false;
 }
 static GpBrush* _GdipCreateBrush(DWORD argb)
 {
@@ -291,11 +291,11 @@ static GpBrush* _GdipCreateBrush(DWORD argb)
 static CFX_DIBitmap* _StretchMonoToGray(int dest_width, int dest_height,
                                         const CFX_DIBitmap* pSource, FX_RECT* pClipRect)
 {
-    FX_BOOL bFlipX = dest_width < 0;
+    bool bFlipX = dest_width < 0;
     if (bFlipX) {
         dest_width = -dest_width;
     }
-    FX_BOOL bFlipY = dest_height < 0;
+    bool bFlipY = dest_height < 0;
     if (bFlipY) {
         dest_height = -dest_height;
     }
@@ -382,7 +382,7 @@ static void OutputImageMask(GpGraphics* pGraphics, BOOL bMonoDevice, const CFX_D
         if (src_width * src_height > 10000) {
             pStretched = _StretchMonoToGray(dest_width, dest_height, pBitmap, &image_clip);
         } else {
-            pStretched = pBitmap->StretchTo(dest_width, dest_height, FALSE, &image_clip);
+            pStretched = pBitmap->StretchTo(dest_width, dest_height, false, &image_clip);
         }
         GpBitmap* bitmap;
         CallFunc(GdipCreateBitmapFromScan0)(image_clip.Width(), image_clip.Height(),
@@ -536,7 +536,7 @@ void CGdiplusExt::DeleteMemFont(LPVOID pCollection)
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     CallFunc(GdipDeletePrivateFontCollection)((GpFontCollection**)&pCollection);
 }
-FX_BOOL CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void**bitmap)
+bool CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void**bitmap)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     PixelFormat format;
@@ -551,41 +551,41 @@ FX_BOOL CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void**bitmap)
             format = PixelFormat32bppARGB;
             break;
         default:
-            return FALSE;
+            return false;
     }
     GpStatus status = CallFunc(GdipCreateBitmapFromScan0)(pBitmap->GetWidth(), pBitmap->GetHeight(),
                       pBitmap->GetPitch(), format, pBitmap->GetBuffer(), (GpBitmap**)bitmap);
     if (status == Ok) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFromImage(void* bitmap, void** graphics)
+bool CGdiplusExt::GdipCreateFromImage(void* bitmap, void** graphics)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     GpStatus status = CallFunc(GdipGetImageGraphicsContext)((GpBitmap*)bitmap, (GpGraphics**)graphics);
     if (status == Ok) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFontFamilyFromName(const FX_WCHAR* name, void* pFontCollection, void**pFamily)
+bool CGdiplusExt::GdipCreateFontFamilyFromName(const FX_WCHAR* name, void* pFontCollection, void**pFamily)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     GpStatus status = CallFunc(GdipCreateFontFamilyFromName)((GDIPCONST WCHAR *)name, (GpFontCollection*)pFontCollection, (GpFontFamily**)pFamily);
     if (status == Ok) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFontFromFamily(void* pFamily, FX_FLOAT font_size, int fontstyle, int flag, void** pFont)
+bool CGdiplusExt::GdipCreateFontFromFamily(void* pFamily, FX_FLOAT font_size, int fontstyle, int flag, void** pFont)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     GpStatus status = CallFunc(GdipCreateFont)((GpFontFamily*)pFamily, font_size, fontstyle, Unit(flag), (GpFont**)pFont);
     if (status == Ok) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 void CGdiplusExt::GdipGetFontSize(void *pFont, FX_FLOAT *size)
 {
@@ -608,16 +608,16 @@ void CGdiplusExt::GdipSetPageUnit(void* graphics, FX_DWORD unit)
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     CallFunc(GdipSetPageUnit)((GpGraphics*)graphics, (GpUnit)unit);
 }
-FX_BOOL CGdiplusExt::GdipDrawDriverString(void *graphics,  unsigned short *text, int length,
+bool CGdiplusExt::GdipDrawDriverString(void *graphics,  unsigned short *text, int length,
         void *font, void* brush, void *positions, int flags, const void *matrix)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     GpStatus status = CallFunc(GdipDrawDriverString)((GpGraphics*)graphics, (GDIPCONST UINT16 *)text, (INT)length, (GDIPCONST GpFont *)font, (GDIPCONST GpBrush*)brush,
                       (GDIPCONST PointF *)positions, (INT)flags, (GDIPCONST GpMatrix *)matrix);
     if (status == Ok) {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 void CGdiplusExt::GdipCreateBrush(FX_DWORD fill_argb, void** pBrush)
 {
@@ -684,7 +684,7 @@ void CGdiplusExt::GdipDeleteGraphics(void* graphics)
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     CallFunc(GdipDeleteGraphics)((GpGraphics*)graphics);
 }
-FX_BOOL CGdiplusExt::StretchBitMask(HDC hDC, BOOL bMonoDevice, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+bool CGdiplusExt::StretchBitMask(HDC hDC, BOOL bMonoDevice, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                     int dest_width, int dest_height, FX_DWORD argb, const FX_RECT* pClipRect, int flags)
 {
     ASSERT(pBitmap->GetBPP() == 1);
@@ -699,9 +699,9 @@ FX_BOOL CGdiplusExt::StretchBitMask(HDC hDC, BOOL bMonoDevice, const CFX_DIBitma
     }
     OutputImageMask(pGraphics, bMonoDevice, pBitmap, dest_left, dest_top, dest_width, dest_height, argb, pClipRect);
     CallFunc(GdipDeleteGraphics)(pGraphics);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiplusExt::StretchDIBits(HDC hDC, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+bool CGdiplusExt::StretchDIBits(HDC hDC, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                    int dest_width, int dest_height, const FX_RECT* pClipRect, int flags)
 {
     GpGraphics* pGraphics;
@@ -719,9 +719,9 @@ FX_BOOL CGdiplusExt::StretchDIBits(HDC hDC, const CFX_DIBitmap* pBitmap, int des
     OutputImage(pGraphics, pBitmap, &src_rect, dest_left, dest_top, dest_width, dest_height);
     CallFunc(GdipDeleteGraphics)(pGraphics);
     CallFunc(GdipDeleteGraphics)(pGraphics);
-    return TRUE;
+    return true;
 }
-static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState, const CFX_AffineMatrix* pMatrix, DWORD argb, FX_BOOL bTextMode = FALSE)
+static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState, const CFX_AffineMatrix* pMatrix, DWORD argb, bool bTextMode = false)
 {
     CGdiplusExt& GdiplusExt = ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
     FX_FLOAT width = pGraphState ? pGraphState->m_LineWidth : 1.0f;
@@ -735,7 +735,7 @@ static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState, const CFX_Af
     CallFunc(GdipCreatePen1)((ARGB)argb, width, UnitWorld, &pPen);
     LineCap lineCap;
     DashCap dashCap = DashCapFlat;
-    FX_BOOL bDashExtend = FALSE;
+    bool bDashExtend = false;
     switch(pGraphState->m_LineCap) {
         case CFX_GraphStateData::LineCapButt:
             lineCap = LineCapFlat;
@@ -743,11 +743,11 @@ static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState, const CFX_Af
         case CFX_GraphStateData::LineCapRound:
             lineCap = LineCapRound;
             dashCap = DashCapRound;
-            bDashExtend = TRUE;
+            bDashExtend = true;
             break;
         case CFX_GraphStateData::LineCapSquare:
             lineCap = LineCapSquare;
-            bDashExtend = TRUE;
+            bDashExtend = true;
             break;
     }
     CallFunc(GdipSetPenLineCap197819)(pPen, lineCap, lineCap, dashCap);
@@ -839,10 +839,10 @@ static BOOL IsSmallTriangle(PointF* points, const CFX_AffineMatrix* pMatrix, int
         if (distance_square < (1.0f * 2 + 1.0f / 4)) {
             v1 = i;
             v2 = pair1;
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
                            const CFX_AffineMatrix* pObject2Device,
@@ -854,7 +854,7 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
 {
     int nPoints = pPathData->GetPointCount();
     if (nPoints == 0) {
-        return TRUE;
+        return true;
     }
     FX_PATHPOINT* pPoints = pPathData->GetPoints();
     GpGraphics* pGraphics = NULL;
@@ -870,9 +870,9 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
     PointF *points = FX_Alloc(PointF, nPoints);
     BYTE * types  = FX_Alloc(BYTE, nPoints);
     int nSubPathes = 0;
-    FX_BOOL bSubClose = FALSE;
+    bool bSubClose = false;
     int pos_subclose = 0;
-    FX_BOOL bSmooth = FALSE;
+    bool bSmooth = false;
     int startpoint = 0;
     for(int i = 0; i < nPoints; i++) {
         points[i].X = pPoints[i].m_PointX;
@@ -900,7 +900,7 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
         if(point_type == FXPT_MOVETO) {
             types[i] = PathPointTypeStart;
             nSubPathes ++;
-            bSubClose = FALSE;
+            bSubClose = false;
             startpoint = i;
         } else if (point_type == FXPT_LINETO) {
             types[i] = PathPointTypeLine;
@@ -910,31 +910,31 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
                 continue;
             }
             if (!bSmooth && points[i].X != points[i - 1].X && points[i].Y != points[i - 1].Y) {
-                bSmooth = TRUE;
+                bSmooth = true;
             }
         } else if (point_type == FXPT_BEZIERTO)	{
             types[i] = PathPointTypeBezier;
-            bSmooth = TRUE;
+            bSmooth = true;
         }
         if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) {
             if (bSubClose) {
                 types[pos_subclose] &= ~PathPointTypeCloseSubpath;
             } else {
-                bSubClose = TRUE;
+                bSubClose = true;
             }
             pos_subclose = i;
             types[i] |= PathPointTypeCloseSubpath;
             if (!bSmooth && points[i].X != points[startpoint].X && points[i].Y != points[startpoint].Y) {
-                bSmooth = TRUE;
+                bSmooth = true;
             }
         }
     }
     if (fill_mode & FXFILL_NOPATHSMOOTH) {
-        bSmooth = FALSE;
+        bSmooth = false;
         CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeNone);
     } else if (!(fill_mode & FXFILL_FULLCOVER)) {
         if (!bSmooth && (fill_mode & 3)) {
-            bSmooth = TRUE;
+            bSmooth = true;
         }
         if (bSmooth || (pGraphState && pGraphState->m_LineWidth > 2)) {
             CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeAntiAlias);
@@ -949,7 +949,7 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
             CallFunc(GdipDrawLineI)(pGraphics, pPen, FXSYS_round(points[v1].X), FXSYS_round(points[v1].Y),
                                     FXSYS_round(points[v2].X), FXSYS_round(points[v2].Y));
             CallFunc(GdipDeletePen)(pPen);
-            return TRUE;
+            return true;
         }
     }
     GpPath* pGpPath = NULL;
@@ -961,7 +961,7 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
         FX_Free(points);
         FX_Free(types);
         CallFunc(GdipDeleteGraphics)(pGraphics);
-        return FALSE;
+        return false;
     }
     if (new_fill_mode) {
         GpBrush* pBrush = _GdipCreateBrush(fill_argb);
@@ -994,7 +994,7 @@ BOOL CGdiplusExt::DrawPath(HDC hDC, const CFX_PathData* pPathData,
     FX_Free(types);
     CallFunc(GdipDeletePath)(pGpPath);
     CallFunc(GdipDeleteGraphics)(pGraphics);
-    return TRUE;
+    return true;
 }
 class GpStream final : public IStream
 {
@@ -1229,7 +1229,7 @@ static void FreeDIBitmap(PREVIEW3_DIBITMAP* pInfo)
     }
     FX_Free(pInfo);
 }
-CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData, FX_BOOL bAlpha);
+CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi, LPVOID pData, bool bAlpha);
 CFX_DIBitmap* CGdiplusExt::LoadDIBitmap(WINDIB_Open_Args_ args)
 {
     PREVIEW3_DIBITMAP* pInfo = ::LoadDIBitmap(args);
diff --git a/core/src/fxge/win32/fx_win32_print.cpp b/core/src/fxge/win32/fx_win32_print.cpp
index 86dbf9bb0a..63c3849237 100644
--- a/core/src/fxge/win32/fx_win32_print.cpp
+++ b/core/src/fxge/win32/fx_win32_print.cpp
@@ -18,7 +18,7 @@ CGdiPrinterDriver::CGdiPrinterDriver(HDC hDC) : CGdiDeviceDriver(hDC, FXDC_PRINT
 {
     m_HorzSize = ::GetDeviceCaps(m_hDC, HORZSIZE);
     m_VertSize = ::GetDeviceCaps(m_hDC, VERTSIZE);
-    m_bSupportROP = TRUE;
+    m_bSupportROP = true;
 }
 int CGdiPrinterDriver::GetDeviceCaps(int caps_id)
 {
@@ -30,7 +30,7 @@ int CGdiPrinterDriver::GetDeviceCaps(int caps_id)
     }
     return CGdiDeviceDriver::GetDeviceCaps(caps_id);
 }
-FX_BOOL CGdiPrinterDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool CGdiPrinterDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                      int alpha_flag, void* pIccTransform)
 {
     if (pSource->IsAlphaMask()) {
@@ -41,28 +41,28 @@ FX_BOOL CGdiPrinterDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD colo
     ASSERT(pSource != NULL && !pSource->IsAlphaMask() && pSrcRect != NULL);
     ASSERT(blend_type == FXDIB_BLEND_NORMAL);
     if (pSource->HasAlpha()) {
-        return FALSE;
+        return false;
     }
     CFX_DIBExtractor temp(pSource);
     CFX_DIBitmap* pBitmap = temp;
     if (pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
 }
-FX_BOOL CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (pSource->IsAlphaMask()) {
         int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
         if (pSource->GetBPP() != 1 || alpha != 255 || !m_bSupportROP) {
-            return FALSE;
+            return false;
         }
         if (dest_width < 0 || dest_height < 0) {
             CFX_DIBitmap* pFlipped = pSource->FlipImage(dest_width < 0, dest_height < 0);
             if (pFlipped == NULL) {
-                return FALSE;
+                return false;
             }
             if (dest_width < 0) {
                 dest_left += dest_width;
@@ -70,24 +70,24 @@ FX_BOOL CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD
             if (dest_height < 0) {
                 dest_top += dest_height;
             }
-            FX_BOOL ret = GDI_StretchBitMask(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), color, flags, alpha_flag, pIccTransform);
+            bool ret = GDI_StretchBitMask(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), color, flags, alpha_flag, pIccTransform);
             delete pFlipped;
             return ret;
         }
         CFX_DIBExtractor temp(pSource);
         CFX_DIBitmap* pBitmap = temp;
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         return GDI_StretchBitMask(pBitmap, dest_left, dest_top, dest_width, dest_height, color, flags, alpha_flag, pIccTransform);
     }
     if (pSource->HasAlpha()) {
-        return FALSE;
+        return false;
     }
     if (dest_width < 0 || dest_height < 0) {
         CFX_DIBitmap* pFlipped = pSource->FlipImage(dest_width < 0, dest_height < 0);
         if (pFlipped == NULL) {
-            return FALSE;
+            return false;
         }
         if (dest_width < 0) {
             dest_left += dest_width;
@@ -95,14 +95,14 @@ FX_BOOL CGdiPrinterDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD
         if (dest_height < 0) {
             dest_top += dest_height;
         }
-        FX_BOOL ret = GDI_StretchDIBits(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), flags, pIccTransform);
+        bool ret = GDI_StretchDIBits(pFlipped, dest_left, dest_top, abs(dest_width), abs(dest_height), flags, pIccTransform);
         delete pFlipped;
         return ret;
     }
     CFX_DIBExtractor temp(pSource);
     CFX_DIBitmap* pBitmap = temp;
     if (pBitmap == NULL) {
-        return FALSE;
+        return false;
     }
     return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width, dest_height, flags, pIccTransform);
 }
@@ -189,18 +189,18 @@ static CFX_DIBitmap* Transform1bppBitmap(const CFX_DIBSource* pSrc, const CFX_Af
     }
     return pTempBitmap;
 }
-FX_BOOL	CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD color,
+bool	CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD color,
                                        const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                        int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (bitmap_alpha < 255 || pSource->HasAlpha() || (pSource->IsAlphaMask() && (pSource->GetBPP() != 1 || !m_bSupportROP))) {
-        return FALSE;
+        return false;
     }
     CFX_FloatRect unit_rect = pMatrix->GetUnitRect();
     FX_RECT full_rect = unit_rect.GetOutterRect();
     if (FXSYS_fabs(pMatrix->b) < 0.5f && pMatrix->a != 0 && FXSYS_fabs(pMatrix->c) < 0.5f && pMatrix->d != 0) {
-        FX_BOOL bFlipX = pMatrix->a < 0;
-        FX_BOOL bFlipY = pMatrix->d > 0;
+        bool bFlipX = pMatrix->a < 0;
+        bool bFlipY = pMatrix->d > 0;
         return StretchDIBits(pSource, color, bFlipX ? full_rect.right : full_rect.left, bFlipY ? full_rect.bottom : full_rect.top,
                              bFlipX ? -full_rect.Width() : full_rect.Width(), bFlipY ? -full_rect.Height() : full_rect.Height(), NULL, 0,
                              alpha_flag, pIccTransform, blend_type);
@@ -208,9 +208,9 @@ FX_BOOL	CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_
     if (FXSYS_fabs(pMatrix->a) < 0.5f && FXSYS_fabs(pMatrix->d) < 0.5f) {
         CFX_DIBitmap* pTransformed = pSource->SwapXY(pMatrix->c > 0, pMatrix->b < 0);
         if (pTransformed == NULL) {
-            return FALSE;
+            return false;
         }
-        FX_BOOL ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,
+        bool ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,
                                     alpha_flag, pIccTransform, blend_type);
         delete pTransformed;
         return ret;
@@ -218,20 +218,20 @@ FX_BOOL	CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_
     if (pSource->GetBPP() == 1) {
         CFX_DIBitmap* pTransformed = Transform1bppBitmap(pSource, pMatrix);
         if (pIccTransform == NULL) {
-            return FALSE;
+            return false;
         }
         SaveState();
         CFX_PathData path;
         path.AppendRect(0, 0, 1.0f, 1.0f);
         SetClip_PathFill(&path, pMatrix, WINDING);
-        FX_BOOL ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,
+        bool ret = StretchDIBits(pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(), full_rect.Height(), NULL, 0,
                                     alpha_flag, pIccTransform, blend_type);
         RestoreState();
         delete pTransformed;
         handle = NULL;
         return ret;
     }
-    return FALSE;
+    return false;
 }
 CPSOutput::CPSOutput(HDC hDC)
 {
@@ -266,14 +266,14 @@ void CPSOutput::OutputPS(const FX_CHAR* string, int len)
 CPSPrinterDriver::CPSPrinterDriver()
 {
     m_pPSOutput = NULL;
-    m_bCmykOutput = FALSE;
+    m_bCmykOutput = false;
 }
 CPSPrinterDriver::~CPSPrinterDriver()
 {
     EndRendering();
     delete m_pPSOutput;
 }
-FX_BOOL CPSPrinterDriver::Init(HDC hDC, int pslevel, FX_BOOL bCmykOutput)
+bool CPSPrinterDriver::Init(HDC hDC, int pslevel, bool bCmykOutput)
 {
     m_hDC = hDC;
     m_HorzSize = ::GetDeviceCaps(m_hDC, HORZSIZE);
@@ -305,7 +305,7 @@ FX_BOOL CPSPrinterDriver::Init(HDC hDC, int pslevel, FX_BOOL bCmykOutput)
         }
     }
     ::DeleteObject(hRgn);
-    return TRUE;
+    return true;
 }
 int CPSPrinterDriver::GetDeviceCaps(int caps_id)
 {
@@ -327,7 +327,7 @@ int CPSPrinterDriver::GetDeviceCaps(int caps_id)
     }
     return 0;
 }
-FX_BOOL CPSPrinterDriver::StartRendering()
+bool CPSPrinterDriver::StartRendering()
 {
     return m_PSRenderer.StartRendering();
 }
@@ -339,69 +339,69 @@ void CPSPrinterDriver::SaveState()
 {
     m_PSRenderer.SaveState();
 }
-void CPSPrinterDriver::RestoreState(FX_BOOL bKeepSaved)
+void CPSPrinterDriver::RestoreState(bool bKeepSaved)
 {
     m_PSRenderer.RestoreState(bKeepSaved);
 }
-FX_BOOL	CPSPrinterDriver::SetClip_PathFill(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device,
+bool	CPSPrinterDriver::SetClip_PathFill(const CFX_PathData* pPathData, const CFX_AffineMatrix* pObject2Device,
         int fill_mode)
 {
     m_PSRenderer.SetClip_PathFill(pPathData, pObject2Device, fill_mode);
-    return TRUE;
+    return true;
 }
-FX_BOOL	CPSPrinterDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
+bool	CPSPrinterDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pObject2Device,
         const CFX_GraphStateData* pGraphState)
 {
     m_PSRenderer.SetClip_PathStroke(pPathData, pObject2Device, pGraphState);
-    return TRUE;
+    return true;
 }
-FX_BOOL	CPSPrinterDriver::DrawPath(const CFX_PathData* pPathData,
+bool	CPSPrinterDriver::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_AffineMatrix* pObject2Device,
                                    const CFX_GraphStateData* pGraphState, FX_ARGB fill_color, FX_ARGB stroke_color,
                                    int fill_mode, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     return m_PSRenderer.DrawPath(pPathData, pObject2Device, pGraphState, fill_color, stroke_color, fill_mode & 3, alpha_flag, pIccTransform);
 }
-FX_BOOL CPSPrinterDriver::GetClipBox(FX_RECT* pRect)
+bool CPSPrinterDriver::GetClipBox(FX_RECT* pRect)
 {
     *pRect = m_PSRenderer.GetClipBox();
-    return TRUE;
+    return true;
 }
-FX_BOOL CPSPrinterDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool CPSPrinterDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                     int alpha_flag, void* pIccTransform)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     return m_PSRenderer.SetDIBits(pBitmap, color, left, top, alpha_flag, pIccTransform);
 }
-FX_BOOL CPSPrinterDriver::StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+bool CPSPrinterDriver::StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                         int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     return m_PSRenderer.StretchDIBits(pBitmap, color, dest_left, dest_top, dest_width, dest_height, flags, alpha_flag, pIccTransform);
 }
-FX_BOOL	CPSPrinterDriver::StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+bool	CPSPrinterDriver::StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                       const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                       int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     if (bitmap_alpha < 255) {
-        return FALSE;
+        return false;
     }
     handle = NULL;
     return m_PSRenderer.DrawDIBits(pBitmap, color, pMatrix, render_flags, alpha_flag, pIccTransform);
 }
-FX_BOOL	CPSPrinterDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+bool	CPSPrinterDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
         CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
         int alpha_flag, void* pIccTransform)
 {
diff --git a/core/src/fxge/win32/win32_int.h b/core/src/fxge/win32/win32_int.h
index 569c4f6baa..f9b6a639b9 100644
--- a/core/src/fxge/win32/win32_int.h
+++ b/core/src/fxge/win32/win32_int.h
@@ -13,15 +13,15 @@ public:
     CGdiplusExt();
     ~CGdiplusExt();
     void			Load();
-    FX_BOOL			IsAvailable()
+    bool			IsAvailable()
     {
         return m_hModule != NULL;
     }
-    FX_BOOL			StretchBitMask(HDC hDC, BOOL bMonoDevice, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+    bool			StretchBitMask(HDC hDC, BOOL bMonoDevice, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                    int dest_width, int dest_height, FX_DWORD argb, const FX_RECT* pClipRect, int flags);
-    FX_BOOL			StretchDIBits(HDC hDC, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+    bool			StretchDIBits(HDC hDC, const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                   int dest_width, int dest_height, const FX_RECT* pClipRect, int flags);
-    FX_BOOL			DrawPath(HDC hDC, const CFX_PathData* pPathData,
+    bool			DrawPath(HDC hDC, const CFX_PathData* pPathData,
                              const CFX_AffineMatrix* pObject2Device,
                              const CFX_GraphStateData* pGraphState,
                              FX_DWORD fill_argb,
@@ -31,26 +31,26 @@ public:
 
     void*			LoadMemFont(uint8_t* pData, FX_DWORD size);
     void			DeleteMemFont(void* pFontCollection);
-    FX_BOOL         GdipCreateFromImage(void* bitmap, void** graphics);
+    bool         GdipCreateFromImage(void* bitmap, void** graphics);
     void            GdipDeleteGraphics(void* graphics);
     void            GdipSetTextRenderingHint(void* graphics, int mode);
     void            GdipSetPageUnit(void* graphics, FX_DWORD unit);
     void            GdipSetWorldTransform(void* graphics, void* pMatrix);
-    FX_BOOL         GdipDrawDriverString(void *graphics,  unsigned short *text, int length, void *font, void* brush, void *positions, int flags, const void *matrix);
+    bool         GdipDrawDriverString(void *graphics,  unsigned short *text, int length, void *font, void* brush, void *positions, int flags, const void *matrix);
     void            GdipCreateBrush(FX_DWORD fill_argb, void** pBrush);
     void            GdipDeleteBrush(void* pBrush);
     void            GdipCreateMatrix(FX_FLOAT a, FX_FLOAT b, FX_FLOAT c, FX_FLOAT d, FX_FLOAT e, FX_FLOAT f, void** matrix);
     void            GdipDeleteMatrix(void* matrix);
-    FX_BOOL         GdipCreateFontFamilyFromName(const FX_WCHAR* name, void* pFontCollection, void**pFamily);
+    bool         GdipCreateFontFamilyFromName(const FX_WCHAR* name, void* pFontCollection, void**pFamily);
     void            GdipDeleteFontFamily(void* pFamily);
-    FX_BOOL         GdipCreateFontFromFamily(void* pFamily, FX_FLOAT font_size, int fontstyle, int flag, void** pFont);
+    bool         GdipCreateFontFromFamily(void* pFamily, FX_FLOAT font_size, int fontstyle, int flag, void** pFont);
     void*           GdipCreateFontFromCollection(void* pFontCollection, FX_FLOAT font_size, int fontstyle);
     void            GdipDeleteFont(void* pFont);
-    FX_BOOL         GdipCreateBitmap(CFX_DIBitmap* pBitmap, void**bitmap);
+    bool         GdipCreateBitmap(CFX_DIBitmap* pBitmap, void**bitmap);
     void            GdipDisposeImage(void* bitmap);
     void            GdipGetFontSize(void *pFont, FX_FLOAT *size);
     void*           GdiAddFontMemResourceEx(void *pFontdata, FX_DWORD size, void* pdv, FX_DWORD* num_face);
-    FX_BOOL         GdiRemoveFontMemResourceEx(void* handle);
+    bool         GdiRemoveFontMemResourceEx(void* handle);
     void*			m_Functions[100];
     void*           m_pGdiAddFontMemResourceEx;
     void*           m_pGdiRemoveFontMemResourseEx;
@@ -63,7 +63,7 @@ protected:
 class CWin32Platform
 {
 public:
-    FX_BOOL			m_bHalfTone;
+    bool			m_bHalfTone;
     CGdiplusExt		m_GdiplusExt;
     CDWriteExt      m_DWriteExt;
 };
@@ -75,22 +75,22 @@ protected:
     {
         SaveDC(m_hDC);
     }
-    virtual void	RestoreState(FX_BOOL bKeepSaved = FALSE)
+    virtual void	RestoreState(bool bKeepSaved = false)
     {
         RestoreDC(m_hDC, -1);
         if (bKeepSaved) {
             SaveDC(m_hDC);
         }
     }
-    virtual FX_BOOL	SetClip_PathFill(const CFX_PathData* pPathData,
+    virtual bool	SetClip_PathFill(const CFX_PathData* pPathData,
                                      const CFX_AffineMatrix* pObject2Device,
                                      int fill_mode
                                     );
-    virtual FX_BOOL	SetClip_PathStroke(const CFX_PathData* pPathData,
+    virtual bool	SetClip_PathStroke(const CFX_PathData* pPathData,
                                        const CFX_AffineMatrix* pObject2Device,
                                        const CFX_GraphStateData* pGraphState
                                       );
-    virtual FX_BOOL	DrawPath(const CFX_PathData* pPathData,
+    virtual bool	DrawPath(const CFX_PathData* pPathData,
                              const CFX_AffineMatrix* pObject2Device,
                              const CFX_GraphStateData* pGraphState,
                              FX_DWORD fill_color,
@@ -100,26 +100,26 @@ protected:
                              void* pIccTransform,
                              int	blend_type
                             );
-    virtual FX_BOOL FillRect(const FX_RECT* pRect,
+    virtual bool FillRect(const FX_RECT* pRect,
                              FX_DWORD fill_color,
                              int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL	DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+    virtual bool	DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
                                      int alpha_flag, void* pIccTransform, int blend_type);
     virtual void* GetClipRgn() ;
-    virtual FX_BOOL SetClipRgn(void* pRgn) ;
-    virtual FX_BOOL GetClipBox(FX_RECT* pRect);
-    virtual FX_BOOL DeleteDeviceRgn(void* pRgn);
+    virtual bool SetClipRgn(void* pRgn) ;
+    virtual bool GetClipBox(FX_RECT* pRect);
+    virtual bool DeleteDeviceRgn(void* pRgn);
     virtual void	DrawLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2);
     virtual void*	GetPlatformSurface()
     {
         return (void*)m_hDC;
     }
-    FX_BOOL			GDI_SetDIBits(const CFX_DIBitmap* pBitmap, const FX_RECT* pSrcRect, int left, int top,
+    bool			GDI_SetDIBits(const CFX_DIBitmap* pBitmap, const FX_RECT* pSrcRect, int left, int top,
                                   void* pIccTransform);
-    FX_BOOL			GDI_StretchDIBits(const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+    bool			GDI_StretchDIBits(const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                       int dest_width, int dest_height, FX_DWORD flags,
                                       void* pIccTransform);
-    FX_BOOL			GDI_StretchBitMask(const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
+    bool			GDI_StretchBitMask(const CFX_DIBitmap* pBitmap, int dest_left, int dest_top,
                                        int dest_width, int dest_height, FX_DWORD bitmap_color, FX_DWORD flags,
                                        int alpha_flag, void* pIccTransform);
     HDC				m_hDC;
@@ -133,19 +133,19 @@ class CGdiDisplayDriver : public CGdiDeviceDriver
 public:
     CGdiDisplayDriver(HDC hDC);
 protected:
-    virtual FX_BOOL GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, FX_BOOL bDEdge = FALSE);
-    virtual FX_BOOL SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+    virtual bool GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform = NULL, bool bDEdge = false);
+    virtual bool SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                               int alpha_flag, void* pIccTransform);
-    virtual FX_BOOL StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+    virtual bool StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                   int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                   int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+    virtual bool	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                 const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                 int alpha_flag, void* pIccTransform, int blend_type)
     {
-        return FALSE;
+        return false;
     }
-    FX_BOOL			UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+    bool			UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
                                           int dest_width, int dest_height, const FX_RECT* pClipRect, int render_flags,
                                           int alpha_flag = 0, void* pIccTransform = NULL, int blend_type = FXDIB_BLEND_NORMAL);
 };
@@ -155,16 +155,16 @@ public:
     CGdiPrinterDriver(HDC hDC);
 protected:
     virtual int		GetDeviceCaps(int caps_id);
-    virtual FX_BOOL SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+    virtual bool SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                               int alpha_flag, void* pIccTransform);
-    virtual FX_BOOL StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+    virtual bool StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                   int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                   int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+    virtual bool	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                 const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                 int alpha_flag, void* pIccTransform, int blend_type);
     int				m_HorzSize, m_VertSize;
-    FX_BOOL			m_bSupportROP;
+    bool			m_bSupportROP;
 };
 class CPSOutput : public IFX_PSOutput
 {
@@ -184,27 +184,27 @@ class CPSPrinterDriver : public IFX_RenderDeviceDriver
 {
 public:
     CPSPrinterDriver();
-    FX_BOOL			Init(HDC hDC, int ps_level, FX_BOOL bCmykOutput);
+    bool			Init(HDC hDC, int ps_level, bool bCmykOutput);
     ~CPSPrinterDriver();
 protected:
-    virtual FX_BOOL IsPSPrintDriver()
+    virtual bool IsPSPrintDriver()
     {
-        return TRUE;
+        return true;
     }
     virtual int		GetDeviceCaps(int caps_id);
-    virtual FX_BOOL	StartRendering();
+    virtual bool	StartRendering();
     virtual void	EndRendering();
     virtual void	SaveState();
-    virtual void	RestoreState(FX_BOOL bKeepSaved = FALSE);
-    virtual FX_BOOL	SetClip_PathFill(const CFX_PathData* pPathData,
+    virtual void	RestoreState(bool bKeepSaved = false);
+    virtual bool	SetClip_PathFill(const CFX_PathData* pPathData,
                                      const CFX_AffineMatrix* pObject2Device,
                                      int fill_mode
                                     );
-    virtual FX_BOOL	SetClip_PathStroke(const CFX_PathData* pPathData,
+    virtual bool	SetClip_PathStroke(const CFX_PathData* pPathData,
                                        const CFX_AffineMatrix* pObject2Device,
                                        const CFX_GraphStateData* pGraphState
                                       );
-    virtual FX_BOOL	DrawPath(const CFX_PathData* pPathData,
+    virtual bool	DrawPath(const CFX_PathData* pPathData,
                              const CFX_AffineMatrix* pObject2Device,
                              const CFX_GraphStateData* pGraphState,
                              FX_DWORD fill_color,
@@ -214,16 +214,16 @@ protected:
                              void* pIccTransform,
                              int blend_type
                             );
-    virtual FX_BOOL GetClipBox(FX_RECT* pRect);
-    virtual FX_BOOL SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+    virtual bool GetClipBox(FX_RECT* pRect);
+    virtual bool SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                               int alpha_flag, void* pIccTransform);
-    virtual FX_BOOL StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
+    virtual bool StretchDIBits(const CFX_DIBSource* pBitmap, FX_DWORD color, int dest_left, int dest_top,
                                   int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                   int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
+    virtual bool	StartDIBits(const CFX_DIBSource* pBitmap, int bitmap_alpha, FX_DWORD color,
                                 const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                 int alpha_flag, void* pIccTransform, int blend_type);
-    virtual FX_BOOL DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+    virtual bool DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
                                    CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FLOAT font_size, FX_DWORD color,
                                    int alpha_flag, void* pIccTransform);
     virtual void*	GetPlatformSurface()
@@ -231,7 +231,7 @@ protected:
         return (void*)m_hDC;
     }
     HDC				m_hDC;
-    FX_BOOL			m_bCmykOutput;
+    bool			m_bCmykOutput;
     int				m_Width, m_Height, m_nBitsPerPixel;
     int				m_HorzSize, m_VertSize;
     CPSOutput*		m_pPSOutput;