FX_BOOL considered harmful.

core/src/fpdfdoc/doc_form.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "../../include/fpdfdoc/fpdf_doc.h"
 #include "doc_utils.h"
 
 const int nMaxRecursion = 32;
@@ skipping 223 matching lines @@
     name_extractor.GetNext(pName, nLength);
     _Node *pNode = &m_Root, *pLast = NULL;
     while (nLength > 0 && pNode) {
         pLast = pNode;
         CFX_WideString name = CFX_WideString(pName, nLength);
         pNode = _Lookup(pLast, name);
         name_extractor.GetNext(pName, nLength);
     }
     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");
     if (m_pFormDict == NULL) {
         return;
     }
     CPDF_Array* pFields = m_pFormDict->GetArray("Fields");
     if (pFields == NULL) {
         return;
     }
@@ skipping 13 matching lines @@
     }
     if (m_pFieldTree != NULL) {
         int nCount = m_pFieldTree->m_Root.CountFields();
         for (int i = 0; i < nCount; i++) {
             CPDF_FormField *pField = m_pFieldTree->m_Root.GetField(i);
             delete pField;
         }
         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;
 }
 CFX_ByteString CPDF_InterForm::GenerateNewResourceName(const CPDF_Dictionary* pResDict, const FX_CHAR* csType, int iMinLen, const FX_CHAR* csPrefix)
 {
     CFX_ByteString csStr = csPrefix;
     CFX_ByteString csBType = csType;
     if (csStr.IsEmpty()) {
         if (csBType == "ExtGState") {
             csStr = "GS";
@@ skipping 22 matching lines @@
     }
     if (pResDict == NULL) {
         return csTmp;
     }
     CPDF_Dictionary* pDict = pResDict->GetDict(csType);
     if (pDict == NULL) {
         return csTmp;
     }
     int num = 0;
     CFX_ByteString bsNum;
-    while (TRUE) {
+    while (true) {
         if (!pDict->KeyExist(csTmp + bsNum)) {
             return csTmp + bsNum;
         }
         if (m < iCount) {
             csTmp += csStr[m ++];
         } else {
             bsNum.Format("%d", num++);
         }
         m ++;
     }
     return csTmp;
 }
 #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,
                                         NEWTEXTMETRICEX *lpntme,
                                         DWORD FontType,
                                         LPARAM lParam
                                      )
 {
     if (FontType != 0x004 || strchr(lpelfe->elfLogFont.lfFaceName, '@') != NULL) {
         return 1;
     } else {
         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));
     HDC hDC = ::GetDC(NULL);
     EnumFontFamiliesExA(hDC, &lf, (FONTENUMPROCA)EnumFontFamExProc, (LPARAM)&fd, 0);
     ::ReleaseDC(NULL, hDC);
     if (fd.bFind) {
         memcpy(&lf, &fd.lf, sizeof(LOGFONTA));
     }
     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;
     lf.lfPitchAndFamily = pitchAndFamily;
     if (pcsFontName != NULL) {
         strcpy(lf.lfFaceName, pcsFontName);
     }
     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) {
         memset(&lf, 0, sizeof(LOGFONTA));
         int iRet = ::GetObject(hFont, sizeof(LOGFONTA), &lf);
         if (iRet > 0 && (lf.lfCharSet == charSet || charSet == 255)) {
             return RetrieveSpecificFont(lf);
         }
     }
-    return FALSE;
+    return false;
 }
 #endif
 CPDF_Font* CPDF_InterForm::AddSystemDefaultFont(const CPDF_Document* pDocument)
 {
     if (pDocument == NULL) {
         return NULL;
     }
     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;
 }
 CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_ByteString csFontName, uint8_t iCharSet)
 {
     if (pDocument == NULL || csFontName.IsEmpty()) {
         return NULL;
     }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     if (iCharSet == 1) {
         iCharSet = GetNativeCharSet();
     }
     HFONT hFont = ::CreateFontA(0, 0, 0, 0, 0, 0, 0, 0, iCharSet, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, csFontName.c_str());
     if (hFont != NULL) {
         LOGFONTA lf;
         memset(&lf, 0, sizeof(LOGFONTA));
         ::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
     return NULL;
 }
 CPDF_Font* CPDF_InterForm::AddSystemFont(const CPDF_Document* pDocument, CFX_WideString csFontName, uint8_t iCharSet)
 {
     if (pDocument == NULL || csFontName.IsEmpty()) {
         return NULL;
     }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     if (iCharSet == 1) {
         iCharSet = GetNativeCharSet();
     }
     HFONT hFont = ::CreateFontW(0, 0, 0, 0, 0, 0, 0, 0, iCharSet, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, csFontName.c_str());
     if (hFont != NULL) {
         LOGFONTA lf;
         memset(&lf, 0, sizeof(LOGFONTA));
         ::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
     return NULL;
 }
 CPDF_Font* CPDF_InterForm::AddStandardFont(const CPDF_Document* pDocument, CFX_ByteString csFontName)
 {
     if (pDocument == NULL || csFontName.IsEmpty()) {
         return NULL;
     }
     CPDF_Font* pFont = NULL;
     if (csFontName == "ZapfDingbats") {
         pFont = ((CPDF_Document*)pDocument)->AddStandardFont(csFontName, NULL);
     } else {
         CPDF_FontEncoding encoding(PDFFONT_ENCODING_WINANSI);
         pFont = ((CPDF_Document*)pDocument)->AddStandardFont(csFontName, &encoding);
     }
     return pFont;
 }
 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) {
         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "SimSun", lf);
     } else if (charSet == CHINESEBIG5_CHARSET) {
         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "MingLiU", lf);
     }
     if (!bRet) {
         bRet = RetrieveSpecificFont(charSet, DEFAULT_PITCH | FF_DONTCARE, "Arial Unicode MS", lf);
     }
@@ skipping 88 matching lines @@
         return NULL;
     }
     CPDF_Font* pFont = NULL;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     LOGFONTA lf;
     CFX_ByteString csFontName = GetNativeFont(charSet, &lf);
     if (!csFontName.IsEmpty()) {
         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
     return pFont;
 }
 CPDF_Font* CPDF_InterForm::AddNativeFont(const CPDF_Document* pDocument)
 {
     if (pDocument == NULL) {
         return NULL;
     }
     CPDF_Font* pFont = NULL;
     uint8_t charSet = GetNativeCharSet();
     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 ++;
         }
         if (iPos < iLength && !csSub.IsEmpty()) {
             csSub += L'.';
         }
         while (iPos < iLength && csNewFieldName[iPos] != L'.') {
             csSub += csNewFieldName[iPos ++];
         }
         for (int i = csSub.GetLength() - 1; i > -1; i --) {
@@ skipping 15 matching lines @@
                         continue;
                     }
                 } else {
                     continue;
                 }
             }
             CFX_WideString csFullName = pField->GetFullName();
             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;
                 }
             }
         }
         if (iPos >= iLength) {
             break;
         }
     }
     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);
 }
 int CPDF_InterForm::CompareFieldName(const CFX_ByteString& name1, const CFX_ByteString& name2)
 {
     const FX_CHAR* ptr1 = name1;
     const FX_CHAR* ptr2 = name2;
     if (name1.GetLength() != name2.GetLength()) {
         int i = 0;
@@ skipping 58 matching lines @@
     allFieldNames.RemoveAll();
     int nCount = m_pFieldTree->m_Root.CountFields();
     for (int i = 0; i < nCount; i ++) {
         CPDF_FormField *pField = m_pFieldTree->m_Root.GetField(i);
         if (pField) {
             CFX_WideString full_name = GetFullName(pField->GetFieldDict());
             allFieldNames.Add(full_name);
         }
     }
 }
-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
 {
     if (pFieldDict == NULL) {
         return NULL;
     }
     CFX_WideString csWName = GetFullName(pFieldDict);
     return m_pFieldTree->GetField(csWName);
 }
 FX_DWORD CPDF_InterForm::CountControls(CFX_WideString csFieldName)
@@ skipping 11 matching lines @@
 {
     CPDF_FormField *pField = m_pFieldTree->GetField(csFieldName);
     if (pField == NULL) {
         return NULL;
     }
     if (index < (FX_DWORD)pField->m_ControlList.GetSize()) {
         return (CPDF_FormControl *)pField->m_ControlList.GetAt(index);
     }
     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) {
         CPDF_Dictionary* pWidgetDict = NULL;
         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
 {
     CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArray("Annots");
     if (pAnnotList == NULL) {
         return 0;
     }
     int count = 0;
     for (FX_DWORD i = 0; i < pAnnotList->GetCount(); i ++) {
         CPDF_Dictionary* pAnnot = pAnnotList->GetDict(i);
@@ skipping 76 matching lines @@
         CPDF_Dictionary* pDict = NULL;
         while (pArray != NULL) {
             CFX_WideString csSub;
             if (iPos < iLength && csFieldName[iPos] == L'.') {
                 iPos ++;
             }
             while (iPos < iLength && csFieldName[iPos] != L'.') {
                 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) {
                     continue;
                 }
                 CFX_WideString csT = pDict->GetUnicodeText("T");
                 if (csT == csSub) {
-                    bFind = TRUE;
+                    bFind = true;
                     break;
                 }
             }
             if (!bFind) {
                 return 0;
             }
             if (iPos >= iLength) {
                 break;
             }
             pArray = pDict->GetArray("Kids");
@@ skipping 27 matching lines @@
         CPDF_Dictionary* pDict = NULL;
         while (pArray != NULL) {
             CFX_WideString csSub;
             if (iPos < iLength && csFieldName[iPos] == L'.') {
                 iPos ++;
             }
             while (iPos < iLength && csFieldName[iPos] != L'.') {
                 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) {
                     continue;
                 }
                 CFX_WideString csT = pDict->GetUnicodeText("T");
                 if (csT == csSub) {
-                    bFind = TRUE;
+                    bFind = true;
                     break;
                 }
             }
             if (!bFind) {
                 return NULL;
             }
             if (iPos >= iLength) {
                 break;
             }
             pArray = pDict->GetArray("Kids");
         }
         if (pDict == NULL) {
             return NULL;
         } else {
             pArray = pDict->GetArray("Kids");
             if (pArray == NULL) {
                 return pDict;
             } else {
                 return pArray->GetDict(index);
             }
         }
     }
 }
-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);
     }
     m_pFormDict->SetAtBoolean("NeedAppearances", bNeedAP);
     m_bGenerateAP = bNeedAP;
 }
 int CPDF_InterForm::CountFieldsInCalculationOrder()
 {
     if (m_pFormDict == NULL) {
@@ skipping 54 matching lines @@
     return GetInterFormFont(m_pFormDict, m_pDocument, csFontName, csNameTag);
 }
 CPDF_Font* CPDF_InterForm::GetNativeFormFont(uint8_t charSet, CFX_ByteString& csNameTag)
 {
     return GetNativeInterFormFont(m_pFormDict, m_pDocument, charSet, csNameTag);
 }
 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()
 {
     CFX_ByteString csDA;
     if (m_pFormDict == NULL) {
         return csDA;
     }
     csDA = m_pFormDict->GetString("DA");
     return csDA;
 }
 CPDF_Font* CPDF_InterForm::GetDefaultFormFont()
 {
     return GetDefaultInterFormFont(m_pFormDict, m_pDocument);
 }
 int CPDF_InterForm::GetFormAlignment()
 {
     if (m_pFormDict == NULL) {
         return 0;
     }
     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();
     for (int i = 0; i < nCount; i++) {
         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
         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;
             }
         }
         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
             pField->ResetField(bNotify);
         }
     }
     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();
     for (int i = 0; i < nCount; i++) {
         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
         if (pField == NULL) {
             continue;
         }
         pField->ResetField(bNotify);
     }
     if (bNotify && m_pFormNotify != NULL) {
         m_pFormNotify->AfterFormReset(this);
     }
-    return TRUE;
+    return true;
 }
 void CPDF_InterForm::ReloadForm()
 {
     FX_POSITION pos = m_ControlMap.GetStartPosition();
     while (pos) {
         CPDF_Dictionary* pWidgetDict;
         CPDF_FormControl* pControl;
         m_ControlMap.GetNextAssoc(pos, (void*&)pWidgetDict, (void*&)pControl);
         delete pControl;
     }
@@ skipping 40 matching lines @@
             if (pChildDict) {
                 if (pChildDict->GetObjNum() != dwParentObjNum) {
                     LoadField(pChildDict, nLevel + 1);
                 }
             }
         }
     } else {
         AddTerminalField(pFieldDict);
     }
 }
-FX_BOOL CPDF_InterForm::HasXFAForm() const
+bool CPDF_InterForm::HasXFAForm() const
 {
     return m_pFormDict && m_pFormDict->GetArray(FX_BSTRC("XFA")) != NULL;
 }
 void CPDF_InterForm::FixPageFields(const CPDF_Page* pPage)
 {
     ASSERT(pPage != NULL);
     CPDF_Dictionary* pPageDict = pPage->m_pFormDict;
     if (pPageDict == NULL) {
         return;
     }
@@ skipping 40 matching lines @@
             if (pFieldDict->KeyExist(FX_BSTRC("Ff"))) {
                 CPDF_Object *pFfValue = pFieldDict->GetElementValue(FX_BSTRC("Ff"));
                 if (pFfValue) {
                     pParent->SetAt(FX_BSTRC("Ff"), pFfValue->Clone());
                 }
             }
         }
         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 {
                 pDict->SetAtName("T", "");
             }
         }
         m_pFieldTree->SetField(csWName, pField);
     }
     CPDF_Array* pKids = pFieldDict->GetArray("Kids");
     if (pKids == NULL) {
@@ skipping 18 matching lines @@
 {
     void *rValue = NULL;
     if (m_ControlMap.Lookup((CPDF_Dictionary*)pWidgetDict, rValue)) {
         return (CPDF_FormControl*)rValue;
     }
     CPDF_FormControl* pControl = new CPDF_FormControl((CPDF_FormField*)pField, (CPDF_Dictionary*)pWidgetDict);
     m_ControlMap.SetAt((CPDF_Dictionary*)pWidgetDict, pControl);
     ((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++) {
         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
         if (pField == NULL) {
             continue;
         }
         int32_t iType = pField->GetType();
         if (iType == CPDF_FormField::PushButton || iType == CPDF_FormField::CheckBox || iType == CPDF_FormField::ListBox) {
             continue;
         }
         FX_DWORD dwFlags = pField->GetFieldFlags();
         if (dwFlags & 0x04) {
             continue;
         }
-        FX_BOOL bFind = TRUE;
+        bool bFind = true;
         if (fields != NULL) {
             bFind = fields->Find(pField, 0) >= 0;
         }
         if ((bIncludeOrExclude && bFind) || (!bIncludeOrExclude && !bFind)) {
             CPDF_Dictionary *pFieldDict = pField->m_pDict;
             if ((dwFlags & 0x02) != 0 && pFieldDict->GetString("V").IsEmpty()) {
                 return pField;
             }
         }
     }
     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();
     for (int i = 0; i < nCount; i ++) {
         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) {
         return NULL;
     }
     CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDict("FDF");
     if (!pdf_path.IsEmpty()) {
         if (bSimpleFileSpec) {
             CFX_WideString wsFilePath = FILESPEC_EncodeFileName(pdf_path);
             pMainDict->SetAtString(FX_BSTRC("F"), CFX_ByteString::FromUnicode(wsFilePath));
@@ skipping 12 matching lines @@
     int nCount = m_pFieldTree->m_Root.CountFields();
     for (int i = 0; i < nCount; i ++) {
         CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
         if (pField == NULL || pField->GetType() == CPDF_FormField::PushButton) {
             continue;
         }
         FX_DWORD dwFlags = pField->GetFieldFlags();
         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;
             }
             CFX_WideString fullname = GetFullName(pField->GetFieldDict());
             CPDF_Dictionary* pFieldDict = CPDF_Dictionary::Create();
             if (pFieldDict == NULL) {
                 return NULL;
             }
             CPDF_String* pString = CPDF_String::Create(fullname);
             if (pString == NULL) {
                 pFieldDict->Release();
                 return NULL;
             }
             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) {
                     pFieldDict->SetAtName("V", csBExport);
                 } else {
                     pFieldDict->SetAtString("V", csBExport);
                 }
             } 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);
         }
     }
     return pDoc;
 }
 const struct _SupportFieldEncoding {
     const FX_CHAR* m_name;
     int32_t m_codePage;
@@ skipping 19 matching lines @@
         csValue.ConvertFrom(csBValue, pCharMap);
         return;
     }
     CFX_ByteString csTemp = csBValue.Left(2);
     if (csTemp == "\xFF\xFE" || csTemp == "\xFE\xFF") {
         csValue = PDF_DecodeText(csBValue);
     } else {
         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()) {
         name = parent_name + L".";
     }
     name += pFieldDict->GetUnicodeText("T");
     CPDF_Array* pKids = pFieldDict->GetArray("Kids");
     if (pKids) {
         for (FX_DWORD i = 0; i < pKids->GetCount(); i ++) {
             CPDF_Dictionary* pKid = pKids->GetDict(i);
@@ skipping 27 matching lines @@
             return;
         }
     }
     CFX_ByteArray statusArray;
     if (iType == FIELDTYPE_CHECKBOX || iType == FIELDTYPE_RADIOBUTTON) {
         SaveCheckedFieldStatus(pField, statusArray);
     }
     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) {
             m_pFormNotify->AfterCheckedStatusChange(pField, statusArray);
         } else if (iType == FIELDTYPE_LISTBOX) {
             m_pFormNotify->AfterSelectionChange(pField);
         } else if (iType == FIELDTYPE_COMBOBOX || iType == FIELDTYPE_TEXTFIELD) {
             m_pFormNotify->AfterValueChange(pField);
         }
     }
     if (CPDF_InterForm::m_bUpdateAP) {
         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 ++) {
         CPDF_Dictionary* pField = pFields->GetDict(i);
         if (pField == NULL) {
             continue;
         }
         FDF_ImportField(pField, L"", 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;
     }
     int iPageCount = m_pDocument->GetPageCount();
     if (iCurPage >= iPageCount) {
         return -1;
     }
     int iNewPage = iCurPage;
     do {
@@ skipping 19 matching lines @@
         for (FX_DWORD i = 0; i < dwCount; i ++) {
             CPDF_Object* pAnnotDict = pAnnots->GetElementValue(i);
             if (pAnnotDict == NULL) {
                 continue;
             }
             CPDF_FormControl* pControl = NULL;
             if (m_ControlMap.Lookup(pAnnotDict, (void*&)pControl)) {
                 return iNewPage;
             }
         }
-    } while (TRUE);
+    } while (true);
     return -1;
 }