Remove FX_BOOL from xfa.

xfa/fxfa/app/xfa_ffwidgetacc.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 "xfa/fxfa/app/xfa_ffwidgetacc.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 54 matching lines @@
 
  private:
   std::unique_ptr<CXFA_TextLayout> m_pTextLayout;
   std::unique_ptr<CXFA_TextProvider> m_pTextProvider;
 };
 
 class CXFA_ImageLayoutData : public CXFA_WidgetLayoutData {
  public:
   CXFA_ImageLayoutData()
       : m_pDIBitmap(nullptr),
-        m_bNamedImage(FALSE),
+        m_bNamedImage(false),
         m_iImageXDpi(0),
         m_iImageYDpi(0) {}
 
   ~CXFA_ImageLayoutData() override {
     if (m_pDIBitmap && !m_bNamedImage)
       delete m_pDIBitmap;
   }
 
-  FX_BOOL LoadImageData(CXFA_WidgetAcc* pAcc) {
+  bool LoadImageData(CXFA_WidgetAcc* pAcc) {
     if (m_pDIBitmap)
-      return TRUE;
+      return true;
 
     CXFA_Value value = pAcc->GetFormValue();
     if (!value)
-      return FALSE;
+      return false;
 
     CXFA_Image imageObj = value.GetImage();
     if (!imageObj)
-      return FALSE;
+      return false;
 
     CXFA_FFDoc* pFFDoc = pAcc->GetDoc();
     pAcc->SetImageImage(XFA_LoadImageData(pFFDoc, &imageObj, m_bNamedImage,
                                           m_iImageXDpi, m_iImageYDpi));
     return !!m_pDIBitmap;
   }
 
   CFX_DIBitmap* m_pDIBitmap;
-  FX_BOOL m_bNamedImage;
+  bool m_bNamedImage;
   int32_t m_iImageXDpi;
   int32_t m_iImageYDpi;
 };
 
 class CXFA_FieldLayoutData : public CXFA_WidgetLayoutData {
  public:
   CXFA_FieldLayoutData() {}
   ~CXFA_FieldLayoutData() override {}
 
-  FX_BOOL LoadCaption(CXFA_WidgetAcc* pAcc) {
+  bool LoadCaption(CXFA_WidgetAcc* pAcc) {
     if (m_pCapTextLayout)
-      return TRUE;
+      return true;
     CXFA_Caption caption = pAcc->GetCaption();
     if (!caption || caption.GetPresence() == XFA_ATTRIBUTEENUM_Hidden)
-      return FALSE;
+      return false;
     m_pCapTextProvider.reset(
         new CXFA_TextProvider(pAcc, XFA_TEXTPROVIDERTYPE_Caption));
     m_pCapTextLayout.reset(new CXFA_TextLayout(m_pCapTextProvider.get()));
-    return TRUE;
+    return true;
   }
 
   std::unique_ptr<CXFA_TextLayout> m_pCapTextLayout;
   std::unique_ptr<CXFA_TextProvider> m_pCapTextProvider;
   std::unique_ptr<CFDE_TextOut> m_pTextOut;
   std::unique_ptr<CFX_FloatArray> m_pFieldSplitArray;
 };
 
 class CXFA_TextEditData : public CXFA_FieldLayoutData {
  public:
 };
 
 class CXFA_ImageEditData : public CXFA_FieldLayoutData {
  public:
   CXFA_ImageEditData()
       : m_pDIBitmap(nullptr),
-        m_bNamedImage(FALSE),
+        m_bNamedImage(false),
         m_iImageXDpi(0),
         m_iImageYDpi(0) {}
 
   ~CXFA_ImageEditData() override {
     if (m_pDIBitmap && !m_bNamedImage)
       delete m_pDIBitmap;
   }
 
-  FX_BOOL LoadImageData(CXFA_WidgetAcc* pAcc) {
+  bool LoadImageData(CXFA_WidgetAcc* pAcc) {
     if (m_pDIBitmap)
-      return TRUE;
+      return true;
 
     CXFA_Value value = pAcc->GetFormValue();
     if (!value)
-      return FALSE;
+      return false;
 
     CXFA_Image imageObj = value.GetImage();
     CXFA_FFDoc* pFFDoc = pAcc->GetDoc();
     pAcc->SetImageEditImage(XFA_LoadImageData(pFFDoc, &imageObj, m_bNamedImage,
                                               m_iImageXDpi, m_iImageYDpi));
     return !!m_pDIBitmap;
   }
 
   CFX_DIBitmap* m_pDIBitmap;
-  FX_BOOL m_bNamedImage;
+  bool m_bNamedImage;
   int32_t m_iImageXDpi;
   int32_t m_iImageYDpi;
 };
 
 CXFA_WidgetAcc::CXFA_WidgetAcc(CXFA_FFDocView* pDocView, CXFA_Node* pNode)
     : CXFA_WidgetData(pNode),
       m_pDocView(pDocView),
       m_nRecursionDepth(0) {}
 
 CXFA_WidgetAcc::~CXFA_WidgetAcc() {}
 
-FX_BOOL CXFA_WidgetAcc::GetName(CFX_WideString& wsName, int32_t iNameType) {
+bool CXFA_WidgetAcc::GetName(CFX_WideString& wsName, int32_t iNameType) {
   if (iNameType == 0) {
     m_pNode->TryCData(XFA_ATTRIBUTE_Name, wsName);
     return !wsName.IsEmpty();
   }
   m_pNode->GetSOMExpression(wsName);
   if (iNameType == 2 && wsName.GetLength() >= 15) {
     CFX_WideStringC wsPre = FX_WSTRC(L"xfa[0].form[0].");
     if (wsPre == CFX_WideStringC(wsName.c_str(), wsPre.GetLength())) {
       wsName.Delete(0, wsPre.GetLength());
     }
   }
-  return TRUE;
+  return true;
 }
 CXFA_Node* CXFA_WidgetAcc::GetDatasets() {
   return m_pNode->GetBindData();
 }
-FX_BOOL CXFA_WidgetAcc::ProcessValueChanged() {
+bool CXFA_WidgetAcc::ProcessValueChanged() {
   m_pDocView->AddValidateWidget(this);
   m_pDocView->AddCalculateWidgetAcc(this);
   m_pDocView->RunCalculateWidgets();
   m_pDocView->RunValidate();
-  return TRUE;
+  return true;
 }
 void CXFA_WidgetAcc::ResetData() {
   CFX_WideString wsValue;
   XFA_Element eUIType = GetUIType();
   switch (eUIType) {
     case XFA_Element::ImageEdit: {
       CXFA_Value imageValue = GetDefaultValue();
       CXFA_Image image = imageValue.GetImage();
       CFX_WideString wsContentType, wsHref;
       if (image) {
@@ skipping 46 matching lines @@
 void CXFA_WidgetAcc::SetImageEdit(const CFX_WideString& wsContentType,
                                   const CFX_WideString& wsHref,
                                   const CFX_WideString& wsData) {
   CXFA_Image image = GetFormValue().GetImage();
   if (image) {
     image.SetContentType(CFX_WideString(wsContentType));
     image.SetHref(wsHref);
   }
   CFX_WideString wsFormatValue(wsData);
   GetFormatDataValue(wsData, wsFormatValue);
-  m_pNode->SetContent(wsData, wsFormatValue, TRUE);
+  m_pNode->SetContent(wsData, wsFormatValue, true);
   CXFA_Node* pBind = GetDatasets();
   if (!pBind) {
     image.SetTransferEncoding(XFA_ATTRIBUTEENUM_Base64);
     return;
   }
   pBind->SetCData(XFA_ATTRIBUTE_ContentType, wsContentType);
   CXFA_Node* pHrefNode = pBind->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (pHrefNode) {
     pHrefNode->SetCData(XFA_ATTRIBUTE_Value, wsHref);
   } else {
@@ skipping 86 matching lines @@
   if (GetRawValue() != EventParam.m_wsResult) {
     SetValue(EventParam.m_wsResult, XFA_VALUEPICTURE_Raw);
     UpdateUIDisplay();
   }
   return XFA_EVENTERROR_Success;
 }
 
 void CXFA_WidgetAcc::ProcessScriptTestValidate(CXFA_Validate validate,
                                                int32_t iRet,
                                                CFXJSE_Value* pRetValue,
-                                               FX_BOOL bVersionFlag) {
+                                               bool bVersionFlag) {
   if (iRet == XFA_EVENTERROR_Success && pRetValue) {
     if (pRetValue->IsBoolean() && !pRetValue->ToBoolean()) {
       IXFA_AppProvider* pAppProvider = GetAppProvider();
       if (!pAppProvider) {
         return;
       }
       CFX_WideString wsTitle;
       pAppProvider->LoadString(XFA_IDS_AppName, wsTitle);
       CFX_WideString wsScriptMsg;
       validate.GetScriptMessageText(wsScriptMsg);
       int32_t eScriptTest = validate.GetScriptTest();
       if (eScriptTest == XFA_ATTRIBUTEENUM_Warning) {
         if (GetNode()->IsUserInteractive())
           return;
         if (wsScriptMsg.IsEmpty())
-          GetValidateMessage(pAppProvider, wsScriptMsg, FALSE, bVersionFlag);
+          GetValidateMessage(pAppProvider, wsScriptMsg, false, bVersionFlag);
 
         if (bVersionFlag) {
           pAppProvider->MsgBox(wsScriptMsg, wsTitle, XFA_MBICON_Warning,
                                XFA_MB_OK);
           return;
         }
         if (pAppProvider->MsgBox(wsScriptMsg, wsTitle, XFA_MBICON_Warning,
                                  XFA_MB_YesNo) == XFA_IDYes) {
           GetNode()->SetFlag(XFA_NodeFlag_UserInteractive, false);
         }
       } else {
         if (wsScriptMsg.IsEmpty()) {
-          GetValidateMessage(pAppProvider, wsScriptMsg, TRUE, bVersionFlag);
+          GetValidateMessage(pAppProvider, wsScriptMsg, true, bVersionFlag);
         }
         pAppProvider->MsgBox(wsScriptMsg, wsTitle, XFA_MBICON_Error, XFA_MB_OK);
       }
     }
   }
 }
 int32_t CXFA_WidgetAcc::ProcessFormatTestValidate(CXFA_Validate validate,
-                                                  FX_BOOL bVersionFlag) {
+                                                  bool bVersionFlag) {
   CFX_WideString wsRawValue = GetRawValue();
   if (!wsRawValue.IsEmpty()) {
     CFX_WideString wsPicture;
     validate.GetPicture(wsPicture);
     if (wsPicture.IsEmpty()) {
       return XFA_EVENTERROR_NotExist;
     }
     IFX_Locale* pLocale = GetLocal();
     if (!pLocale) {
       return XFA_EVENTERROR_NotExist;
     }
     CXFA_LocaleValue lcValue = XFA_GetLocaleValue(this);
     if (!lcValue.ValidateValue(lcValue.GetValue(), wsPicture, pLocale)) {
       IXFA_AppProvider* pAppProvider = GetAppProvider();
       if (!pAppProvider) {
         return XFA_EVENTERROR_NotExist;
       }
       CFX_WideString wsFormatMsg;
       validate.GetFormatMessageText(wsFormatMsg);
       CFX_WideString wsTitle;
       pAppProvider->LoadString(XFA_IDS_AppName, wsTitle);
       int32_t eFormatTest = validate.GetFormatTest();
       if (eFormatTest == XFA_ATTRIBUTEENUM_Error) {
         if (wsFormatMsg.IsEmpty()) {
-          GetValidateMessage(pAppProvider, wsFormatMsg, TRUE, bVersionFlag);
+          GetValidateMessage(pAppProvider, wsFormatMsg, true, bVersionFlag);
         }
         pAppProvider->MsgBox(wsFormatMsg, wsTitle, XFA_MBICON_Error, XFA_MB_OK);
         return XFA_EVENTERROR_Success;
       }
       if (GetNode()->IsUserInteractive())
         return XFA_EVENTERROR_NotExist;
       if (wsFormatMsg.IsEmpty())
-        GetValidateMessage(pAppProvider, wsFormatMsg, FALSE, bVersionFlag);
+        GetValidateMessage(pAppProvider, wsFormatMsg, false, bVersionFlag);
 
       if (bVersionFlag) {
         pAppProvider->MsgBox(wsFormatMsg, wsTitle, XFA_MBICON_Warning,
                              XFA_MB_OK);
         return XFA_EVENTERROR_Success;
       }
       if (pAppProvider->MsgBox(wsFormatMsg, wsTitle, XFA_MBICON_Warning,
                                XFA_MB_YesNo) == XFA_IDYes) {
         GetNode()->SetFlag(XFA_NodeFlag_UserInteractive, false);
       }
       return XFA_EVENTERROR_Success;
     }
   }
   return XFA_EVENTERROR_NotExist;
 }
 int32_t CXFA_WidgetAcc::ProcessNullTestValidate(CXFA_Validate validate,
                                                 int32_t iFlags,
-                                                FX_BOOL bVersionFlag) {
+                                                bool bVersionFlag) {
   CFX_WideString wsValue;
   GetValue(wsValue, XFA_VALUEPICTURE_Raw);
   if (!wsValue.IsEmpty()) {
     return XFA_EVENTERROR_Success;
   }
   if (m_bIsNull && (m_bPreNull == m_bIsNull)) {
     return XFA_EVENTERROR_Success;
   }
   int32_t eNullTest = validate.GetNullTest();
   CFX_WideString wsNullMsg;
@@ skipping 29 matching lines @@
         GetValidateCaptionName(wsCaptionName, bVersionFlag);
         CFX_WideString wsError;
         pAppProvider->LoadString(XFA_IDS_ValidateNullError, wsError);
         wsNullMsg.Format(wsError.c_str(), wsCaptionName.c_str());
       }
       pAppProvider->MsgBox(wsNullMsg, wsTitle, XFA_MBICON_Status, XFA_MB_OK);
       return XFA_EVENTERROR_Error;
     }
     case XFA_ATTRIBUTEENUM_Warning: {
       if (GetNode()->IsUserInteractive())
-        return TRUE;
+        return true;
 
       if (wsNullMsg.IsEmpty()) {
         GetValidateCaptionName(wsCaptionName, bVersionFlag);
         CFX_WideString wsWarning;
         pAppProvider->LoadString(XFA_IDS_ValidateNullWarning, wsWarning);
         wsNullMsg.Format(wsWarning.c_str(), wsCaptionName.c_str(),
                          wsCaptionName.c_str());
       }
       if (pAppProvider->MsgBox(wsNullMsg, wsTitle, XFA_MBICON_Warning,
                                XFA_MB_YesNo) == XFA_IDYes) {
         GetNode()->SetFlag(XFA_NodeFlag_UserInteractive, false);
       }
       return XFA_EVENTERROR_Error;
     }
     case XFA_ATTRIBUTEENUM_Disabled:
     default:
       break;
   }
   return XFA_EVENTERROR_Success;
 }
 void CXFA_WidgetAcc::GetValidateCaptionName(CFX_WideString& wsCaptionName,
-                                            FX_BOOL bVersionFlag) {
+                                            bool bVersionFlag) {
   if (!bVersionFlag) {
     CXFA_Caption caption = GetCaption();
     if (caption) {
       CXFA_Value capValue = caption.GetValue();
       if (capValue) {
         CXFA_Text capText = capValue.GetText();
         if (capText) {
           capText.GetContent(wsCaptionName);
         }
       }
     }
   }
   if (wsCaptionName.IsEmpty()) {
     GetName(wsCaptionName);
   }
 }
 void CXFA_WidgetAcc::GetValidateMessage(IXFA_AppProvider* pAppProvider,
                                         CFX_WideString& wsMessage,
-                                        FX_BOOL bError,
-                                        FX_BOOL bVersionFlag) {
+                                        bool bError,
+                                        bool bVersionFlag) {
   CFX_WideString wsCaptionName;
   GetValidateCaptionName(wsCaptionName, bVersionFlag);
   CFX_WideString wsError;
   if (bVersionFlag) {
     pAppProvider->LoadString(XFA_IDS_ValidateFailed, wsError);
     wsMessage.Format(wsError.c_str(), wsCaptionName.c_str());
     return;
   }
   if (bError) {
     pAppProvider->LoadString(XFA_IDS_ValidateError, wsError);
     wsMessage.Format(wsError.c_str(), wsCaptionName.c_str());
     return;
   }
   CFX_WideString wsWarning;
   pAppProvider->LoadString(XFA_IDS_ValidateWarning, wsWarning);
   wsMessage.Format(wsWarning.c_str(), wsCaptionName.c_str(),
                    wsCaptionName.c_str());
 }
 int32_t CXFA_WidgetAcc::ProcessValidate(int32_t iFlags) {
   if (GetElementType() == XFA_Element::Draw) {
     return XFA_EVENTERROR_NotExist;
   }
   CXFA_Validate validate = GetValidate();
   if (!validate) {
     return XFA_EVENTERROR_NotExist;
   }
-  FX_BOOL bInitDoc = validate.GetNode()->NeedsInitApp();
-  FX_BOOL bStatus =
-      m_pDocView->GetLayoutStatus() < XFA_DOCVIEW_LAYOUTSTATUS_End;
+  bool bInitDoc = validate.GetNode()->NeedsInitApp();
+  bool bStatus = m_pDocView->GetLayoutStatus() < XFA_DOCVIEW_LAYOUTSTATUS_End;
   int32_t iFormat = 0;
   CFXJSE_Value* pRetValue = nullptr;
   int32_t iRet = XFA_EVENTERROR_NotExist;
   CXFA_Script script = validate.GetScript();
   if (script) {
     CXFA_EventParam eParam;
     eParam.m_eType = XFA_EVENT_Validate;
     eParam.m_pTarget = this;
     iRet = ExecuteScript(script, &eParam,
                          ((bInitDoc || bStatus) && GetRawValue().IsEmpty())
                              ? nullptr
                              : &pRetValue);
   }
   XFA_VERSION version = GetDoc()->GetXFADoc()->GetCurVersionMode();
-  FX_BOOL bVersionFlag = FALSE;
+  bool bVersionFlag = false;
   if (version < XFA_VERSION_208) {
-    bVersionFlag = TRUE;
+    bVersionFlag = true;
   }
   if (bInitDoc) {
     validate.GetNode()->ClearFlag(XFA_NodeFlag_NeedsInitApp);
   } else {
     iFormat = ProcessFormatTestValidate(validate, bVersionFlag);
     if (!bVersionFlag) {
       bVersionFlag = GetDoc()->GetXFADoc()->HasFlag(XFA_DOCFLAG_Scripting);
     }
     iRet |= ProcessNullTestValidate(validate, iFlags, bVersionFlag);
   }
@@ skipping 31 matching lines @@
   pContext->SetEventParam(*pEventParam);
   pContext->SetRunAtType((XFA_ATTRIBUTEENUM)script.GetRunAt());
   CXFA_NodeArray refNodes;
   if (pEventParam->m_eType == XFA_EVENT_InitCalculate ||
       pEventParam->m_eType == XFA_EVENT_Calculate) {
     pContext->SetNodesOfRunScript(&refNodes);
   }
   std::unique_ptr<CFXJSE_Value> pTmpRetValue(
       new CFXJSE_Value(pContext->GetRuntime()));
   ++m_nRecursionDepth;
-  FX_BOOL bRet = pContext->RunScript((XFA_SCRIPTLANGTYPE)eScriptType,
-                                     wsExpression.AsStringC(),
-                                     pTmpRetValue.get(), m_pNode);
+  bool bRet = pContext->RunScript((XFA_SCRIPTLANGTYPE)eScriptType,
+                                  wsExpression.AsStringC(), pTmpRetValue.get(),
+                                  m_pNode);
   --m_nRecursionDepth;
   int32_t iRet = XFA_EVENTERROR_Error;
   if (bRet) {
     iRet = XFA_EVENTERROR_Success;
     if (pEventParam->m_eType == XFA_EVENT_Calculate ||
         pEventParam->m_eType == XFA_EVENT_InitCalculate) {
       if (!pTmpRetValue->IsUndefined()) {
         if (!pTmpRetValue->IsNull())
           pEventParam->m_wsResult = pTmpRetValue->ToWideString();
 
@@ skipping 102 matching lines @@
     mgCap.GetBottomInset(fBottomInset);
     if (bReserveExit) {
       bVert ? (szCap.x += fLeftInset + fRightInset)
             : (szCap.y += fTopInset + fBottomInset);
     } else {
       szCap.x += fLeftInset + fRightInset;
       szCap.y += fTopInset + fBottomInset;
     }
   }
 }
-FX_BOOL CXFA_WidgetAcc::CalculateFieldAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateFieldAutoSize(CFX_SizeF& size) {
   CFX_SizeF szCap;
   CalcCaptionSize(szCap);
   CFX_RectF rtUIMargin;
   GetUIMargin(rtUIMargin);
   size.x += rtUIMargin.left + rtUIMargin.width;
   size.y += rtUIMargin.top + rtUIMargin.height;
   if (szCap.x > 0 && szCap.y > 0) {
     int32_t iCapPlacement = GetCaption().GetPlacementType();
     switch (iCapPlacement) {
       case XFA_ATTRIBUTEENUM_Left:
       case XFA_ATTRIBUTEENUM_Right:
       case XFA_ATTRIBUTEENUM_Inline: {
         size.x += szCap.x;
         size.y = std::max(size.y, szCap.y);
       } break;
       case XFA_ATTRIBUTEENUM_Top:
       case XFA_ATTRIBUTEENUM_Bottom: {
         size.y += szCap.y;
         size.x = std::max(size.x, szCap.x);
       }
       default:
         break;
     }
   }
   return CalculateWidgetAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculateWidgetAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateWidgetAutoSize(CFX_SizeF& size) {
   CXFA_Margin mgWidget = GetMargin();
   if (mgWidget) {
     FX_FLOAT fLeftInset, fTopInset, fRightInset, fBottomInset;
     mgWidget.GetLeftInset(fLeftInset);
     mgWidget.GetTopInset(fTopInset);
     mgWidget.GetRightInset(fRightInset);
     mgWidget.GetBottomInset(fBottomInset);
     size.x += fLeftInset + fRightInset;
     size.y += fTopInset + fBottomInset;
   }
@@ skipping 17 matching lines @@
   if (GetHeight(fVal)) {
     size.y = fVal;
   } else {
     if (GetMinHeight(fMin)) {
       size.y = std::max(size.y, fMin);
     }
     if (GetMaxHeight(fMax) && fMax > 0) {
       size.y = std::min(size.y, fMax);
     }
   }
-  return TRUE;
+  return true;
 }
 void CXFA_WidgetAcc::CalculateTextContentSize(CFX_SizeF& size) {
   FX_FLOAT fFontSize = GetFontSize();
   CFX_WideString wsText;
   GetValue(wsText, XFA_VALUEPICTURE_Display);
   if (wsText.IsEmpty()) {
     size.y += fFontSize;
     return;
   }
   FX_WCHAR wcEnter = '\n';
@@ skipping 13 matching lines @@
     pTextOut->SetLineSpace(GetLineHeight());
     uint32_t dwStyles = FDE_TTOSTYLE_LastLineHeight;
     if (GetUIType() == XFA_Element::TextEdit && IsMultiLine()) {
       dwStyles |= FDE_TTOSTYLE_LineWrap;
     }
     pTextOut->SetStyles(dwStyles);
   }
   layoutData->m_pTextOut->CalcLogicSize(wsText.c_str(), wsText.GetLength(),
                                         size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculateTextEditAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateTextEditAutoSize(CFX_SizeF& size) {
   if (size.x > 0) {
     CFX_SizeF szOrz = size;
     CFX_SizeF szCap;
     CalcCaptionSize(szCap);
-    FX_BOOL bCapExit = szCap.x > 0.01 && szCap.y > 0.01;
+    bool bCapExit = szCap.x > 0.01 && szCap.y > 0.01;
     int32_t iCapPlacement = XFA_ATTRIBUTEENUM_Unknown;
     if (bCapExit) {
       iCapPlacement = GetCaption().GetPlacementType();
       switch (iCapPlacement) {
         case XFA_ATTRIBUTEENUM_Left:
         case XFA_ATTRIBUTEENUM_Right:
         case XFA_ATTRIBUTEENUM_Inline: {
           size.x -= szCap.x;
         }
         default:
@@ skipping 26 matching lines @@
         default:
           break;
       }
     }
     size.x = szOrz.x;
     return CalculateWidgetAutoSize(size);
   }
   CalculateTextContentSize(size);
   return CalculateFieldAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculateCheckButtonAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateCheckButtonAutoSize(CFX_SizeF& size) {
   FX_FLOAT fCheckSize = GetCheckButtonSize();
   size.x = size.y = fCheckSize;
   return CalculateFieldAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculatePushButtonAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculatePushButtonAutoSize(CFX_SizeF& size) {
   CalcCaptionSize(size);
   return CalculateWidgetAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculateImageAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateImageAutoSize(CFX_SizeF& size) {
   if (!GetImageImage()) {
     LoadImageImage();
   }
   size.clear();
   if (CFX_DIBitmap* pBitmap = GetImageImage()) {
     CFX_RectF rtImage, rtFit;
     rtImage.Set(0, 0, 0, 0);
     rtFit.Set(0, 0, 0, 0);
     int32_t iImageXDpi = 0;
     int32_t iImageYDpi = 0;
@@ skipping 10 matching lines @@
     if (GetHeight(rtFit.height)) {
       GetHeightWithoutMargin(rtFit.height);
     } else {
       rtFit.height = rtImage.height;
     }
     size.x = rtFit.width;
     size.y = rtFit.height;
   }
   return CalculateWidgetAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::CalculateImageEditAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateImageEditAutoSize(CFX_SizeF& size) {
   if (!GetImageEditImage()) {
     LoadImageEditImage();
   }
   size.clear();
   if (CFX_DIBitmap* pBitmap = GetImageEditImage()) {
     CFX_RectF rtImage, rtFit;
     rtImage.Set(0, 0, 0, 0);
     rtFit.Set(0, 0, 0, 0);
     int32_t iImageXDpi = 0;
     int32_t iImageYDpi = 0;
@@ skipping 10 matching lines @@
     if (GetHeight(rtFit.height)) {
       GetHeightWithoutMargin(rtFit.height);
     } else {
       rtFit.height = rtImage.height;
     }
     size.x = rtFit.width;
     size.y = rtFit.height;
   }
   return CalculateFieldAutoSize(size);
 }
-FX_BOOL CXFA_WidgetAcc::LoadImageImage() {
+bool CXFA_WidgetAcc::LoadImageImage() {
   InitLayoutData();
   return static_cast<CXFA_ImageLayoutData*>(m_pLayoutData.get())
       ->LoadImageData(this);
 }
-FX_BOOL CXFA_WidgetAcc::LoadImageEditImage() {
+bool CXFA_WidgetAcc::LoadImageEditImage() {
   InitLayoutData();
   return static_cast<CXFA_ImageEditData*>(m_pLayoutData.get())
       ->LoadImageData(this);
 }
 void CXFA_WidgetAcc::GetImageDpi(int32_t& iImageXDpi, int32_t& iImageYDpi) {
   CXFA_ImageLayoutData* pData =
       static_cast<CXFA_ImageLayoutData*>(m_pLayoutData.get());
   iImageXDpi = pData->m_iImageXDpi;
   iImageYDpi = pData->m_iImageYDpi;
 }
 void CXFA_WidgetAcc::GetImageEditDpi(int32_t& iImageXDpi, int32_t& iImageYDpi) {
   CXFA_ImageEditData* pData =
       static_cast<CXFA_ImageEditData*>(m_pLayoutData.get());
   iImageXDpi = pData->m_iImageXDpi;
   iImageYDpi = pData->m_iImageYDpi;
 }
-FX_BOOL CXFA_WidgetAcc::CalculateTextAutoSize(CFX_SizeF& size) {
+bool CXFA_WidgetAcc::CalculateTextAutoSize(CFX_SizeF& size) {
   LoadText();
   CXFA_TextLayout* pTextLayout =
       static_cast<CXFA_TextLayoutData*>(m_pLayoutData.get())->GetTextLayout();
   if (pTextLayout) {
     size.x = pTextLayout->StartLayout(size.x);
     size.y = pTextLayout->GetLayoutHeight();
   }
   return CalculateWidgetAutoSize(size);
 }
 void CXFA_WidgetAcc::LoadText() {
@@ skipping 119 matching lines @@
     case XFA_Element::ExclGroup:
       CalculateWidgetAutoSize(sz);
       break;
     default:
       break;
   }
   fWidth = sz.x;
   m_pLayoutData->m_fWidgetHeight = sz.y;
   fCalcHeight = sz.y;
 }
-FX_BOOL CXFA_WidgetAcc::FindSplitPos(int32_t iBlockIndex,
-                                     FX_FLOAT& fCalcHeight) {
+bool CXFA_WidgetAcc::FindSplitPos(int32_t iBlockIndex, FX_FLOAT& fCalcHeight) {
   XFA_Element eUIType = GetUIType();
   if (eUIType == XFA_Element::Subform) {
-    return FALSE;
+    return false;
   }
   if (eUIType != XFA_Element::Text && eUIType != XFA_Element::TextEdit &&
       eUIType != XFA_Element::NumericEdit &&
       eUIType != XFA_Element::PasswordEdit) {
     fCalcHeight = 0;
-    return TRUE;
+    return true;
   }
   FX_FLOAT fTopInset = 0;
   FX_FLOAT fBottomInset = 0;
   if (iBlockIndex == 0) {
     CXFA_Margin mgWidget = GetMargin();
     if (mgWidget) {
       mgWidget.GetTopInset(fTopInset);
       mgWidget.GetBottomInset(fBottomInset);
     }
     CFX_RectF rtUIMargin;
@@ skipping 11 matching lines @@
     }
     CXFA_TextLayout* pTextLayout =
         static_cast<CXFA_TextLayoutData*>(m_pLayoutData.get())->GetTextLayout();
     pTextLayout->DoLayout(iBlockIndex, fCalcHeight, fCalcHeight,
                           m_pLayoutData->m_fWidgetHeight - fTopInset);
     if (fCalcHeight != 0) {
       if (iBlockIndex == 0) {
         fCalcHeight = fCalcHeight + fTopInset;
       }
       if (fabs(fHeight - fCalcHeight) < XFA_FLOAT_PERCISION) {
-        return FALSE;
+        return false;
       }
     }
-    return TRUE;
+    return true;
   }
   XFA_ATTRIBUTEENUM iCapPlacement = XFA_ATTRIBUTEENUM_Unknown;
   FX_FLOAT fCapReserve = 0;
   if (iBlockIndex == 0) {
     CXFA_Caption caption = GetCaption();
     if (caption && caption.GetPresence() != XFA_ATTRIBUTEENUM_Hidden) {
       iCapPlacement = (XFA_ATTRIBUTEENUM)caption.GetPlacementType();
       fCapReserve = caption.GetReserve();
     }
     if (iCapPlacement == XFA_ATTRIBUTEENUM_Top &&
         fCalcHeight < fCapReserve + fTopInset) {
       fCalcHeight = 0;
-      return TRUE;
+      return true;
     }
     if (iCapPlacement == XFA_ATTRIBUTEENUM_Bottom &&
         m_pLayoutData->m_fWidgetHeight - fCapReserve - fBottomInset) {
       fCalcHeight = 0;
-      return TRUE;
+      return true;
     }
     if (iCapPlacement != XFA_ATTRIBUTEENUM_Top) {
       fCapReserve = 0;
     }
   }
   CXFA_FieldLayoutData* pFieldData =
       static_cast<CXFA_FieldLayoutData*>(m_pLayoutData.get());
   int32_t iLinesCount = 0;
   FX_FLOAT fHeight = m_pLayoutData->m_fWidgetHeight;
   CFX_WideString wsText;
@@ skipping 11 matching lines @@
   if (!pFieldData->m_pFieldSplitArray) {
     pFieldData->m_pFieldSplitArray.reset(new CFX_FloatArray);
   }
   CFX_FloatArray* pFieldArray = pFieldData->m_pFieldSplitArray.get();
   int32_t iFieldSplitCount = pFieldArray->GetSize();
   for (int32_t i = 0; i < iBlockIndex * 3; i += 3) {
     iLinesCount -= (int32_t)pFieldArray->GetAt(i + 1);
     fHeight -= pFieldArray->GetAt(i + 2);
   }
   if (iLinesCount == 0) {
-    return FALSE;
+    return false;
   }
   FX_FLOAT fLineHeight = GetLineHeight();
   FX_FLOAT fFontSize = GetFontSize();
   FX_FLOAT fTextHeight = iLinesCount * fLineHeight - fLineHeight + fFontSize;
   FX_FLOAT fSpaceAbove = 0;
   FX_FLOAT fStartOffset = 0;
   if (fHeight > 0.1f && iBlockIndex == 0) {
     fStartOffset = fTopInset;
     fHeight -= (fTopInset + fBottomInset);
     if (CXFA_Para para = GetPara()) {
@@ skipping 21 matching lines @@
     if (fStartOffset < 0.1f) {
       fStartOffset = 0;
     }
   }
   if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
     pFieldArray->SetAt(0, fStartOffset);
   } else {
     pFieldArray->Add(fStartOffset);
   }
   XFA_VERSION version = GetDoc()->GetXFADoc()->GetCurVersionMode();
-  FX_BOOL bCanSplitNoContent = FALSE;
+  bool bCanSplitNoContent = false;
   XFA_ATTRIBUTEENUM eLayoutMode;
   GetNode()
       ->GetNodeItem(XFA_NODEITEM_Parent)
-      ->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, TRUE);
+      ->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, true);
   if ((eLayoutMode == XFA_ATTRIBUTEENUM_Position ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Tb ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Row ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Table) &&
       version > XFA_VERSION_208) {
-    bCanSplitNoContent = TRUE;
+    bCanSplitNoContent = true;
   }
   if ((eLayoutMode == XFA_ATTRIBUTEENUM_Tb ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Row ||
        eLayoutMode == XFA_ATTRIBUTEENUM_Table) &&
       version <= XFA_VERSION_208) {
     if (fStartOffset < fCalcHeight) {
-      bCanSplitNoContent = TRUE;
+      bCanSplitNoContent = true;
     } else {
       fCalcHeight = 0;
-      return TRUE;
+      return true;
     }
   }
   if (bCanSplitNoContent) {
     if ((fCalcHeight - fTopInset - fSpaceAbove < fLineHeight)) {
       fCalcHeight = 0;
-      return TRUE;
+      return true;
     }
     if (fStartOffset + XFA_FLOAT_PERCISION >= fCalcHeight) {
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
         pFieldArray->SetAt(iBlockIndex * 3 + 1, 0);
         pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
       } else {
         pFieldArray->Add(0);
         pFieldArray->Add(fCalcHeight);
       }
-      return FALSE;
+      return false;
     }
     if (fCalcHeight - fStartOffset < fLineHeight) {
       fCalcHeight = fStartOffset;
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
         pFieldArray->SetAt(iBlockIndex * 3 + 1, 0);
         pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
       } else {
         pFieldArray->Add(0);
         pFieldArray->Add(fCalcHeight);
       }
-      return TRUE;
+      return true;
     }
     FX_FLOAT fTextNum =
         fCalcHeight + XFA_FLOAT_PERCISION - fCapReserve - fStartOffset;
     int32_t iLineNum =
         (int32_t)((fTextNum + (fLineHeight - fFontSize)) / fLineHeight);
     if (iLineNum >= iLinesCount) {
       if (fCalcHeight - fStartOffset - fTextHeight >= fFontSize) {
         if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
           pFieldArray->SetAt(iBlockIndex * 3 + 1, (FX_FLOAT)iLinesCount);
           pFieldArray->SetAt(iBlockIndex * 3 + 2, fCalcHeight);
         } else {
           pFieldArray->Add((FX_FLOAT)iLinesCount);
           pFieldArray->Add(fCalcHeight);
         }
-        return FALSE;
+        return false;
       }
       if (fHeight - fStartOffset - fTextHeight < fFontSize) {
         iLineNum -= 1;
         if (iLineNum == 0) {
           fCalcHeight = 0;
-          return TRUE;
+          return true;
         }
       } else {
         iLineNum = (int32_t)(fTextNum / fLineHeight);
       }
     }
     if (iLineNum > 0) {
       FX_FLOAT fSplitHeight =
           iLineNum * fLineHeight + fCapReserve + fStartOffset;
       if (iFieldSplitCount / 3 == (iBlockIndex + 1)) {
         pFieldArray->SetAt(iBlockIndex * 3 + 1, (FX_FLOAT)iLineNum);
         pFieldArray->SetAt(iBlockIndex * 3 + 2, fSplitHeight);
       } else {
         pFieldArray->Add((FX_FLOAT)iLineNum);
         pFieldArray->Add(fSplitHeight);
       }
       if (fabs(fSplitHeight - fCalcHeight) < XFA_FLOAT_PERCISION) {
-        return FALSE;
+        return false;
       }
       fCalcHeight = fSplitHeight;
-      return TRUE;
+      return true;
     }
   }
   fCalcHeight = 0;
-  return TRUE;
+  return true;
 }
 void CXFA_WidgetAcc::InitLayoutData() {
   if (m_pLayoutData) {
     return;
   }
   switch (GetUIType()) {
     case XFA_Element::Text:
       m_pLayoutData.reset(new CXFA_TextLayoutData);
       return;
     case XFA_Element::TextEdit:
@@ skipping 28 matching lines @@
     fTextHeight = GetHeightWithoutMargin(fTextHeight);
     pTextLayout->DoLayout(0, fTextHeight, -1, fTextHeight);
     return;
   }
   if (fCalcWidth > 0 && fCalcHeight < 0) {
     FX_FLOAT fWidth = GetWidthWithoutMargin(fCalcWidth);
     pTextLayout->StartLayout(fWidth);
   }
   if (fCalcWidth < 0 && fCalcHeight < 0) {
     FX_FLOAT fMaxWidth = -1;
-    FX_BOOL bRet = GetWidth(fMaxWidth);
+    bool bRet = GetWidth(fMaxWidth);
     if (bRet) {
       FX_FLOAT fWidth = GetWidthWithoutMargin(fMaxWidth);
       pTextLayout->StartLayout(fWidth);
     } else {
       FX_FLOAT fWidth = pTextLayout->StartLayout(fMaxWidth);
       fMaxWidth = CalculateWidgetAutoWidth(fWidth);
       fWidth = GetWidthWithoutMargin(fMaxWidth);
       pTextLayout->StartLayout(fWidth);
     }
     fCalcWidth = fMaxWidth;
   }
   if (m_pLayoutData->m_fWidgetHeight < 0) {
     m_pLayoutData->m_fWidgetHeight = pTextLayout->GetLayoutHeight();
     m_pLayoutData->m_fWidgetHeight =
         CalculateWidgetAutoHeight(m_pLayoutData->m_fWidgetHeight);
   }
   fTextHeight = m_pLayoutData->m_fWidgetHeight;
   fTextHeight = GetHeightWithoutMargin(fTextHeight);
   pTextLayout->DoLayout(0, fTextHeight, -1, fTextHeight);
   fCalcHeight = m_pLayoutData->m_fWidgetHeight;
 }
-FX_BOOL CXFA_WidgetAcc::LoadCaption() {
+bool CXFA_WidgetAcc::LoadCaption() {
   InitLayoutData();
   return static_cast<CXFA_FieldLayoutData*>(m_pLayoutData.get())
       ->LoadCaption(this);
 }
 CXFA_TextLayout* CXFA_WidgetAcc::GetCaptionTextLayout() {
   return m_pLayoutData
              ? static_cast<CXFA_FieldLayoutData*>(m_pLayoutData.get())
                    ->m_pCapTextLayout.get()
              : nullptr;
 }
@@ skipping 76 matching lines @@
     fLineHeight = GetFontSize() * 1.2f;
   }
   return fLineHeight;
 }
 FX_ARGB CXFA_WidgetAcc::GetTextColor() {
   if (CXFA_Font font = GetFont()) {
     return font.GetColor();
   }
   return 0xFF000000;
 }
-CXFA_Node* CXFA_TextProvider::GetTextNode(FX_BOOL& bRichText) {
-  bRichText = FALSE;
+CXFA_Node* CXFA_TextProvider::GetTextNode(bool& bRichText) {
+  bRichText = false;
   if (m_pTextNode) {
     if (m_pTextNode->GetElementType() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
       m_pTextNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType,
-                                FALSE);
+                                false);
       if (wsContentType == FX_WSTRC(L"text/html")) {
-        bRichText = TRUE;
+        bRichText = true;
       }
     }
     return m_pTextNode;
   }
   if (m_eType == XFA_TEXTPROVIDERTYPE_Text) {
     CXFA_Node* pElementNode = m_pWidgetAcc->GetNode();
     CXFA_Node* pValueNode = pElementNode->GetChild(0, XFA_Element::Value);
     if (!pValueNode) {
       return nullptr;
     }
     CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (pChildNode && pChildNode->GetElementType() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
-      pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+      pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, false);
       if (wsContentType == FX_WSTRC(L"text/html")) {
-        bRichText = TRUE;
+        bRichText = true;
       }
     }
     return pChildNode;
   } else if (m_eType == XFA_TEXTPROVIDERTYPE_Datasets) {
     CXFA_Node* pBind = m_pWidgetAcc->GetDatasets();
     CFDE_XMLNode* pXMLNode = pBind->GetXMLMappingNode();
     ASSERT(pXMLNode);
     for (CFDE_XMLNode* pXMLChild =
              pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pXMLChild;
          pXMLChild = pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (pXMLChild->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLChild);
         if (XFA_RecognizeRichText(pElement)) {
-          bRichText = TRUE;
+          bRichText = true;
         }
       }
     }
     return pBind;
   } else if (m_eType == XFA_TEXTPROVIDERTYPE_Caption) {
     CXFA_Node* pCaptionNode =
         m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Caption);
     if (!pCaptionNode) {
       return nullptr;
     }
     CXFA_Node* pValueNode = pCaptionNode->GetChild(0, XFA_Element::Value);
     if (!pValueNode) {
       return nullptr;
     }
     CXFA_Node* pChildNode = pValueNode->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (pChildNode && pChildNode->GetElementType() == XFA_Element::ExData) {
       CFX_WideString wsContentType;
-      pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+      pChildNode->GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, false);
       if (wsContentType == FX_WSTRC(L"text/html")) {
-        bRichText = TRUE;
+        bRichText = true;
       }
     }
     return pChildNode;
   }
   CXFA_Node* pItemNode =
       m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Items);
   if (!pItemNode) {
     return nullptr;
   }
   CXFA_Node* pNode = pItemNode->GetNodeItem(XFA_NODEITEM_FirstChild);
@@ skipping 22 matching lines @@
   if (m_eType == XFA_TEXTPROVIDERTYPE_Text) {
     return m_pWidgetAcc->GetFont();
   }
   CXFA_Node* pNode = m_pWidgetAcc->GetNode()->GetChild(0, XFA_Element::Caption);
   pNode = pNode->GetChild(0, XFA_Element::Font);
   if (pNode) {
     return CXFA_Font(pNode);
   }
   return m_pWidgetAcc->GetFont();
 }
-FX_BOOL CXFA_TextProvider::IsCheckButtonAndAutoWidth() {
+bool CXFA_TextProvider::IsCheckButtonAndAutoWidth() {
   XFA_Element eType = m_pWidgetAcc->GetUIType();
   if (eType == XFA_Element::CheckButton) {
     FX_FLOAT fWidth = 0;
     return !m_pWidgetAcc->GetWidth(fWidth);
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXFA_TextProvider::GetEmbbedObj(FX_BOOL bURI,
-                                        FX_BOOL bRaw,
-                                        const CFX_WideString& wsAttr,
-                                        CFX_WideString& wsValue) {
+bool CXFA_TextProvider::GetEmbbedObj(bool bURI,
+                                     bool bRaw,
+                                     const CFX_WideString& wsAttr,
+                                     CFX_WideString& wsValue) {
   if (m_eType != XFA_TEXTPROVIDERTYPE_Text) {
-    return FALSE;
+    return false;
   }
   if (bURI) {
     CXFA_Node* pWidgetNode = m_pWidgetAcc->GetNode();
     CXFA_Node* pParent = pWidgetNode->GetNodeItem(XFA_NODEITEM_Parent);
     CXFA_Document* pDocument = pWidgetNode->GetDocument();
     CXFA_Node* pIDNode = nullptr;
     CXFA_WidgetAcc* pEmbAcc = nullptr;
     if (pParent) {
       pIDNode = pDocument->GetNodeByID(pParent, wsAttr.AsStringC());
     }
     if (!pIDNode) {
       pIDNode = pDocument->GetNodeByID(
           ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Form)),
           wsAttr.AsStringC());
     }
     if (pIDNode) {
       pEmbAcc = static_cast<CXFA_WidgetAcc*>(pIDNode->GetWidgetData());
     }
     if (pEmbAcc) {
       pEmbAcc->GetValue(wsValue, XFA_VALUEPICTURE_Display);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }