Remove FX_BOOL from xfa.

xfa/fxfa/parser/cxfa_widgetdata.cpp

 // Copyright 2016 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/parser/cxfa_widgetdata.h"
 
 #include "core/fxcrt/fx_ext.h"
 #include "xfa/fxbarcode/BC_Library.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/cxfa_document.h"
 #include "xfa/fxfa/parser/cxfa_event.h"
 #include "xfa/fxfa/parser/cxfa_measurement.h"
 #include "xfa/fxfa/parser/xfa_localevalue.h"
 #include "xfa/fxfa/parser/xfa_object.h"
 
 namespace {
 
 FX_FLOAT GetEdgeThickness(const CXFA_StrokeArray& strokes,
-                          FX_BOOL b3DStyle,
+                          bool b3DStyle,
                           int32_t nIndex) {
   FX_FLOAT fThickness = 0;
 
   if (strokes[nIndex * 2 + 1].GetPresence() == XFA_ATTRIBUTEENUM_Visible) {
     if (nIndex == 0)
       fThickness += 2.5f;
 
     fThickness += strokes[nIndex * 2 + 1].GetThickness() * (b3DStyle ? 4 : 2);
   }
   return fThickness;
 }
 
-FX_BOOL SplitDateTime(const CFX_WideString& wsDateTime,
-                      CFX_WideString& wsDate,
-                      CFX_WideString& wsTime) {
+bool SplitDateTime(const CFX_WideString& wsDateTime,
+                   CFX_WideString& wsDate,
+                   CFX_WideString& wsTime) {
   wsDate = L"";
   wsTime = L"";
   if (wsDateTime.IsEmpty())
-    return FALSE;
+    return false;
 
   int nSplitIndex = -1;
   nSplitIndex = wsDateTime.Find('T');
   if (nSplitIndex < 0)
     nSplitIndex = wsDateTime.Find(' ');
   if (nSplitIndex < 0)
-    return FALSE;
+    return false;
 
   wsDate = wsDateTime.Left(nSplitIndex);
   if (!wsDate.IsEmpty()) {
     int32_t iCount = wsDate.GetLength();
     int32_t i = 0;
     for (i = 0; i < iCount; i++) {
       if (wsDate[i] >= '0' && wsDate[i] <= '9')
         break;
     }
     if (i == iCount)
-      return FALSE;
+      return false;
   }
   wsTime = wsDateTime.Right(wsDateTime.GetLength() - nSplitIndex - 1);
   if (!wsTime.IsEmpty()) {
     int32_t iCount = wsTime.GetLength();
     int32_t i = 0;
     for (i = 0; i < iCount; i++) {
       if (wsTime[i] >= '0' && wsTime[i] <= '9')
         break;
     }
     if (i == iCount)
-      return FALSE;
+      return false;
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_Node* CreateUIChild(CXFA_Node* pNode, XFA_Element& eWidgetType) {
   XFA_Element eType = pNode->GetElementType();
   eWidgetType = eType;
   if (eType != XFA_Element::Field && eType != XFA_Element::Draw)
     return nullptr;
 
   eWidgetType = XFA_Element::Unknown;
   XFA_Element eUIType = XFA_Element::Unknown;
-  CXFA_Value defValue(pNode->GetProperty(0, XFA_Element::Value, TRUE));
+  CXFA_Value defValue(pNode->GetProperty(0, XFA_Element::Value, true));
   XFA_Element eValueType = defValue.GetChildValueClassID();
   switch (eValueType) {
     case XFA_Element::Boolean:
       eUIType = XFA_Element::CheckButton;
       break;
     case XFA_Element::Integer:
     case XFA_Element::Decimal:
     case XFA_Element::Float:
       eUIType = XFA_Element::NumericEdit;
       break;
@@ skipping 15 matching lines @@
     case XFA_Element::Line:
     case XFA_Element::Rectangle:
       eUIType = XFA_Element::DefaultUi;
       eWidgetType = eValueType;
       break;
     default:
       break;
   }
 
   CXFA_Node* pUIChild = nullptr;
-  CXFA_Node* pUI = pNode->GetProperty(0, XFA_Element::Ui, TRUE);
+  CXFA_Node* pUI = pNode->GetProperty(0, XFA_Element::Ui, true);
   CXFA_Node* pChild = pUI->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     XFA_Element eChildType = pChild->GetElementType();
     if (eChildType == XFA_Element::Extras ||
         eChildType == XFA_Element::Picture) {
       continue;
     }
     const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
         XFA_Element::Ui, eChildType, XFA_XDPPACKET_Form);
     if (pProperty && (pProperty->uFlags & XFA_PROPERTYFLAG_OneOf)) {
@@ skipping 24 matching lines @@
       eWidgetType =
           pUIChild ? pUIChild->GetElementType()
                    : (eUIType == XFA_Element::Unknown ? XFA_Element::TextEdit
                                                       : eUIType);
     }
   }
 
   if (!pUIChild) {
     if (eUIType == XFA_Element::Unknown) {
       eUIType = XFA_Element::TextEdit;
-      defValue.GetNode()->GetProperty(0, XFA_Element::Text, TRUE);
+      defValue.GetNode()->GetProperty(0, XFA_Element::Text, true);
     }
-    return pUI->GetProperty(0, eUIType, TRUE);
+    return pUI->GetProperty(0, eUIType, true);
   }
 
   if (eUIType != XFA_Element::Unknown)
     return pUIChild;
 
   switch (pUIChild->GetElementType()) {
     case XFA_Element::CheckButton: {
       eValueType = XFA_Element::Text;
       if (CXFA_Node* pItems = pNode->GetChild(0, XFA_Element::Items)) {
         if (CXFA_Node* pItem = pItems->GetChild(0, XFA_Element::Unknown))
@@ skipping 19 matching lines @@
     }
     case XFA_Element::Barcode:
     case XFA_Element::Button:
     case XFA_Element::PasswordEdit:
     case XFA_Element::Signature:
     case XFA_Element::TextEdit:
     default:
       eValueType = XFA_Element::Text;
       break;
   }
-  defValue.GetNode()->GetProperty(0, eValueType, TRUE);
+  defValue.GetNode()->GetProperty(0, eValueType, true);
 
   return pUIChild;
 }
 
 XFA_ATTRIBUTEENUM GetAttributeDefaultValue_Enum(XFA_Element eElement,
                                                 XFA_ATTRIBUTE eAttribute,
                                                 uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Enum, dwPacket)) {
     return (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
   }
   return XFA_ATTRIBUTEENUM_Unknown;
 }
 
 CFX_WideStringC GetAttributeDefaultValue_Cdata(XFA_Element eElement,
                                                XFA_ATTRIBUTE eAttribute,
                                                uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Cdata, dwPacket)) {
     return (const FX_WCHAR*)pValue;
   }
   return nullptr;
 }
 
-FX_BOOL GetAttributeDefaultValue_Boolean(XFA_Element eElement,
-                                         XFA_ATTRIBUTE eAttribute,
-                                         uint32_t dwPacket) {
+bool GetAttributeDefaultValue_Boolean(XFA_Element eElement,
+                                      XFA_ATTRIBUTE eAttribute,
+                                      uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Boolean, dwPacket)) {
     return !!pValue;
   }
-  return FALSE;
+  return false;
 }
 
 }  // namespace
 
 CXFA_WidgetData::CXFA_WidgetData(CXFA_Node* pNode)
     : CXFA_Data(pNode),
-      m_bIsNull(TRUE),
-      m_bPreNull(TRUE),
+      m_bIsNull(true),
+      m_bPreNull(true),
       m_pUiChildNode(nullptr),
       m_eUIType(XFA_Element::Unknown) {}
 
 CXFA_Node* CXFA_WidgetData::GetUIChild() {
   if (m_eUIType == XFA_Element::Unknown)
     m_pUiChildNode = CreateUIChild(m_pNode, m_eUIType);
 
   return m_pUiChildNode;
 }
 
 XFA_Element CXFA_WidgetData::GetUIType() {
   GetUIChild();
   return m_eUIType;
 }
 
 CFX_WideString CXFA_WidgetData::GetRawValue() {
   return m_pNode->GetContent();
 }
 
-int32_t CXFA_WidgetData::GetAccess(FX_BOOL bTemplate) {
+int32_t CXFA_WidgetData::GetAccess(bool bTemplate) {
   if (bTemplate) {
     CXFA_Node* pNode = m_pNode->GetTemplateNode();
     if (pNode)
       return pNode->GetEnum(XFA_ATTRIBUTE_Access);
     return XFA_ATTRIBUTEENUM_Open;
   }
   CXFA_Node* pNode = m_pNode;
   while (pNode) {
     int32_t iAcc = pNode->GetEnum(XFA_ATTRIBUTE_Access);
     if (iAcc != XFA_ATTRIBUTEENUM_Open)
       return iAcc;
 
     pNode =
         pNode->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
   }
   return XFA_ATTRIBUTEENUM_Open;
 }
 
 int32_t CXFA_WidgetData::GetRotate() {
   CXFA_Measurement ms;
-  if (!m_pNode->TryMeasure(XFA_ATTRIBUTE_Rotate, ms, FALSE))
+  if (!m_pNode->TryMeasure(XFA_ATTRIBUTE_Rotate, ms, false))
     return 0;
 
   int32_t iRotate = FXSYS_round(ms.GetValue());
   iRotate = XFA_MapRotation(iRotate);
   return iRotate / 90 * 90;
 }
 
-CXFA_Border CXFA_WidgetData::GetBorder(FX_BOOL bModified) {
+CXFA_Border CXFA_WidgetData::GetBorder(bool bModified) {
   return CXFA_Border(m_pNode->GetProperty(0, XFA_Element::Border, bModified));
 }
 
-CXFA_Caption CXFA_WidgetData::GetCaption(FX_BOOL bModified) {
+CXFA_Caption CXFA_WidgetData::GetCaption(bool bModified) {
   return CXFA_Caption(m_pNode->GetProperty(0, XFA_Element::Caption, bModified));
 }
 
-CXFA_Font CXFA_WidgetData::GetFont(FX_BOOL bModified) {
+CXFA_Font CXFA_WidgetData::GetFont(bool bModified) {
   return CXFA_Font(m_pNode->GetProperty(0, XFA_Element::Font, bModified));
 }
 
-CXFA_Margin CXFA_WidgetData::GetMargin(FX_BOOL bModified) {
+CXFA_Margin CXFA_WidgetData::GetMargin(bool bModified) {
   return CXFA_Margin(m_pNode->GetProperty(0, XFA_Element::Margin, bModified));
 }
 
-CXFA_Para CXFA_WidgetData::GetPara(FX_BOOL bModified) {
+CXFA_Para CXFA_WidgetData::GetPara(bool bModified) {
   return CXFA_Para(m_pNode->GetProperty(0, XFA_Element::Para, bModified));
 }
 
 void CXFA_WidgetData::GetEventList(CXFA_NodeArray& events) {
   m_pNode->GetNodeList(events, 0, XFA_Element::Event);
 }
 
 int32_t CXFA_WidgetData::GetEventByActivity(int32_t iActivity,
                                             CXFA_NodeArray& events,
-                                            FX_BOOL bIsFormReady) {
+                                            bool bIsFormReady) {
   CXFA_NodeArray allEvents;
   GetEventList(allEvents);
   int32_t iCount = allEvents.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_Event event(allEvents[i]);
     if (event.GetActivity() == iActivity) {
       if (iActivity == XFA_ATTRIBUTEENUM_Ready) {
         CFX_WideStringC wsRef;
         event.GetRef(wsRef);
         if (bIsFormReady) {
           if (wsRef == CFX_WideStringC(L"$form"))
             events.Add(allEvents[i]);
         } else {
           if (wsRef == CFX_WideStringC(L"$layout"))
             events.Add(allEvents[i]);
         }
       } else {
         events.Add(allEvents[i]);
       }
     }
   }
   return events.GetSize();
 }
 
-CXFA_Value CXFA_WidgetData::GetDefaultValue(FX_BOOL bModified) {
+CXFA_Value CXFA_WidgetData::GetDefaultValue(bool bModified) {
   CXFA_Node* pTemNode = m_pNode->GetTemplateNode();
   return CXFA_Value(
       pTemNode ? pTemNode->GetProperty(0, XFA_Element::Value, bModified)
                : nullptr);
 }
 
-CXFA_Value CXFA_WidgetData::GetFormValue(FX_BOOL bModified) {
+CXFA_Value CXFA_WidgetData::GetFormValue(bool bModified) {
   return CXFA_Value(m_pNode->GetProperty(0, XFA_Element::Value, bModified));
 }
 
-CXFA_Calculate CXFA_WidgetData::GetCalculate(FX_BOOL bModified) {
+CXFA_Calculate CXFA_WidgetData::GetCalculate(bool bModified) {
   return CXFA_Calculate(
       m_pNode->GetProperty(0, XFA_Element::Calculate, bModified));
 }
 
-CXFA_Validate CXFA_WidgetData::GetValidate(FX_BOOL bModified) {
+CXFA_Validate CXFA_WidgetData::GetValidate(bool bModified) {
   return CXFA_Validate(
       m_pNode->GetProperty(0, XFA_Element::Validate, bModified));
 }
 
-CXFA_Bind CXFA_WidgetData::GetBind(FX_BOOL bModified) {
+CXFA_Bind CXFA_WidgetData::GetBind(bool bModified) {
   return CXFA_Bind(m_pNode->GetProperty(0, XFA_Element::Bind, bModified));
 }
 
-CXFA_Assist CXFA_WidgetData::GetAssist(FX_BOOL bModified) {
+CXFA_Assist CXFA_WidgetData::GetAssist(bool bModified) {
   return CXFA_Assist(m_pNode->GetProperty(0, XFA_Element::Assist, bModified));
 }
 
-FX_BOOL CXFA_WidgetData::GetWidth(FX_FLOAT& fWidth) {
+bool CXFA_WidgetData::GetWidth(FX_FLOAT& fWidth) {
   return TryMeasure(XFA_ATTRIBUTE_W, fWidth);
 }
 
-FX_BOOL CXFA_WidgetData::GetHeight(FX_FLOAT& fHeight) {
+bool CXFA_WidgetData::GetHeight(FX_FLOAT& fHeight) {
   return TryMeasure(XFA_ATTRIBUTE_H, fHeight);
 }
 
-FX_BOOL CXFA_WidgetData::GetMinWidth(FX_FLOAT& fMinWidth) {
+bool CXFA_WidgetData::GetMinWidth(FX_FLOAT& fMinWidth) {
   return TryMeasure(XFA_ATTRIBUTE_MinW, fMinWidth);
 }
 
-FX_BOOL CXFA_WidgetData::GetMinHeight(FX_FLOAT& fMinHeight) {
+bool CXFA_WidgetData::GetMinHeight(FX_FLOAT& fMinHeight) {
   return TryMeasure(XFA_ATTRIBUTE_MinH, fMinHeight);
 }
 
-FX_BOOL CXFA_WidgetData::GetMaxWidth(FX_FLOAT& fMaxWidth) {
+bool CXFA_WidgetData::GetMaxWidth(FX_FLOAT& fMaxWidth) {
   return TryMeasure(XFA_ATTRIBUTE_MaxW, fMaxWidth);
 }
 
-FX_BOOL CXFA_WidgetData::GetMaxHeight(FX_FLOAT& fMaxHeight) {
+bool CXFA_WidgetData::GetMaxHeight(FX_FLOAT& fMaxHeight) {
   return TryMeasure(XFA_ATTRIBUTE_MaxH, fMaxHeight);
 }
 
-CXFA_Border CXFA_WidgetData::GetUIBorder(FX_BOOL bModified) {
+CXFA_Border CXFA_WidgetData::GetUIBorder(bool bModified) {
   CXFA_Node* pUIChild = GetUIChild();
   return CXFA_Border(
       pUIChild ? pUIChild->GetProperty(0, XFA_Element::Border, bModified)
                : nullptr);
 }
 
-CXFA_Margin CXFA_WidgetData::GetUIMargin(FX_BOOL bModified) {
+CXFA_Margin CXFA_WidgetData::GetUIMargin(bool bModified) {
   CXFA_Node* pUIChild = GetUIChild();
   return CXFA_Margin(
       pUIChild ? pUIChild->GetProperty(0, XFA_Element::Margin, bModified)
                : nullptr);
 }
 
 void CXFA_WidgetData::GetUIMargin(CFX_RectF& rtUIMargin) {
   rtUIMargin.Reset();
   CXFA_Margin mgUI = GetUIMargin();
   if (!mgUI)
     return;
 
   CXFA_Border border = GetUIBorder();
   if (border && border.GetPresence() != XFA_ATTRIBUTEENUM_Visible)
     return;
 
   FX_FLOAT fLeftInset, fTopInset, fRightInset, fBottomInset;
-  FX_BOOL bLeft = mgUI.GetLeftInset(fLeftInset);
-  FX_BOOL bTop = mgUI.GetTopInset(fTopInset);
-  FX_BOOL bRight = mgUI.GetRightInset(fRightInset);
-  FX_BOOL bBottom = mgUI.GetBottomInset(fBottomInset);
+  bool bLeft = mgUI.GetLeftInset(fLeftInset);
+  bool bTop = mgUI.GetTopInset(fTopInset);
+  bool bRight = mgUI.GetRightInset(fRightInset);
+  bool bBottom = mgUI.GetBottomInset(fBottomInset);
   if (border) {
-    FX_BOOL bVisible = FALSE;
+    bool bVisible = false;
     FX_FLOAT fThickness = 0;
     border.Get3DStyle(bVisible, fThickness);
     if (!bLeft || !bTop || !bRight || !bBottom) {
       CXFA_StrokeArray strokes;
       border.GetStrokes(strokes);
       if (!bTop)
         fTopInset = GetEdgeThickness(strokes, bVisible, 0);
       if (!bRight)
         fRightInset = GetEdgeThickness(strokes, bVisible, 1);
       if (!bBottom)
         fBottomInset = GetEdgeThickness(strokes, bVisible, 2);
       if (!bLeft)
         fLeftInset = GetEdgeThickness(strokes, bVisible, 3);
     }
   }
   rtUIMargin.Set(fLeftInset, fTopInset, fRightInset, fBottomInset);
 }
 
 int32_t CXFA_WidgetData::GetButtonHighlight() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Highlight);
   return GetAttributeDefaultValue_Enum(
       XFA_Element::Button, XFA_ATTRIBUTE_Highlight, XFA_XDPPACKET_Form);
 }
 
-FX_BOOL CXFA_WidgetData::GetButtonRollover(CFX_WideString& wsRollover,
-                                           FX_BOOL& bRichText) {
+bool CXFA_WidgetData::GetButtonRollover(CFX_WideString& wsRollover,
+                                        bool& bRichText) {
   if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     while (pText) {
       CFX_WideStringC wsName;
       pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
       if (wsName == FX_WSTRC(L"rollover")) {
         pText->TryContent(wsRollover);
         bRichText = pText->GetElementType() == XFA_Element::ExData;
         return !wsRollover.IsEmpty();
       }
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetButtonDown(CFX_WideString& wsDown,
-                                       FX_BOOL& bRichText) {
+bool CXFA_WidgetData::GetButtonDown(CFX_WideString& wsDown, bool& bRichText) {
   if (CXFA_Node* pItems = m_pNode->GetChild(0, XFA_Element::Items)) {
     CXFA_Node* pText = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     while (pText) {
       CFX_WideStringC wsName;
       pText->TryCData(XFA_ATTRIBUTE_Name, wsName);
       if (wsName == FX_WSTRC(L"down")) {
         pText->TryContent(wsDown);
         bRichText = pText->GetElementType() == XFA_Element::ExData;
         return !wsDown.IsEmpty();
       }
       pText = pText->GetNodeItem(XFA_NODEITEM_NextSibling);
     }
   }
-  return FALSE;
+  return false;
 }
 
 int32_t CXFA_WidgetData::GetCheckButtonShape() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Shape);
   return GetAttributeDefaultValue_Enum(XFA_Element::CheckButton,
                                        XFA_ATTRIBUTE_Shape, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetCheckButtonMark() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Mark);
   return GetAttributeDefaultValue_Enum(XFA_Element::CheckButton,
                                        XFA_ATTRIBUTE_Mark, XFA_XDPPACKET_Form);
 }
 
-FX_BOOL CXFA_WidgetData::IsRadioButton() {
+bool CXFA_WidgetData::IsRadioButton() {
   if (CXFA_Node* pParent = m_pNode->GetNodeItem(XFA_NODEITEM_Parent))
     return pParent->GetElementType() == XFA_Element::ExclGroup;
-  return FALSE;
+  return false;
 }
 
 FX_FLOAT CXFA_WidgetData::GetCheckButtonSize() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetMeasure(XFA_ATTRIBUTE_Size).ToUnit(XFA_UNIT_Pt);
   return XFA_GetAttributeDefaultValue_Measure(
              XFA_Element::CheckButton, XFA_ATTRIBUTE_Size, XFA_XDPPACKET_Form)
       .ToUnit(XFA_UNIT_Pt);
 }
 
-FX_BOOL CXFA_WidgetData::IsAllowNeutral() {
+bool CXFA_WidgetData::IsAllowNeutral() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_AllowNeutral);
   return GetAttributeDefaultValue_Boolean(
       XFA_Element::CheckButton, XFA_ATTRIBUTE_AllowNeutral, XFA_XDPPACKET_Form);
 }
 
 XFA_CHECKSTATE CXFA_WidgetData::GetCheckState() {
   CFX_WideString wsValue = GetRawValue();
   if (wsValue.IsEmpty())
@@ skipping 105 matching lines @@
       CXFA_WidgetData widgetData(pNode);
       widgetData.SetCheckState(XFA_CHECKSTATE_On, bNotify);
       return pNode;
     }
   }
   return nullptr;
 }
 
 void CXFA_WidgetData::SetSelectedMemberByValue(const CFX_WideStringC& wsValue,
                                                bool bNotify,
-                                               FX_BOOL bScriptModify,
-                                               FX_BOOL bSyncData) {
+                                               bool bScriptModify,
+                                               bool bSyncData) {
   CFX_WideString wsExclGroup;
   for (CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() != XFA_Element::Field)
       continue;
 
     CXFA_Node* pItem = pNode->GetChild(0, XFA_Element::Items);
     if (!pItem)
       continue;
 
     CXFA_Node* pItemchild = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (!pItemchild)
       continue;
 
     CFX_WideString wsChildValue = pItemchild->GetContent();
     if (wsValue != wsChildValue) {
       pItemchild = pItemchild->GetNodeItem(XFA_NODEITEM_NextSibling);
       if (pItemchild)
         wsChildValue = pItemchild->GetContent();
       else
         wsChildValue.clear();
     } else {
       wsExclGroup = wsValue;
     }
     pNode->SetContent(wsChildValue, wsChildValue, bNotify, bScriptModify,
-                      FALSE);
+                      false);
   }
   if (m_pNode) {
     m_pNode->SetContent(wsExclGroup, wsExclGroup, bNotify, bScriptModify,
                         bSyncData);
   }
 }
 
 CXFA_Node* CXFA_WidgetData::GetExclGroupFirstMember() {
   CXFA_Node* pExcl = GetNode();
   if (!pExcl)
@@ skipping 23 matching lines @@
 }
 
 int32_t CXFA_WidgetData::GetChoiceListCommitOn() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_CommitOn);
   return GetAttributeDefaultValue_Enum(
       XFA_Element::ChoiceList, XFA_ATTRIBUTE_CommitOn, XFA_XDPPACKET_Form);
 }
 
-FX_BOOL CXFA_WidgetData::IsChoiceListAllowTextEntry() {
+bool CXFA_WidgetData::IsChoiceListAllowTextEntry() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_TextEntry);
   return GetAttributeDefaultValue_Boolean(
       XFA_Element::ChoiceList, XFA_ATTRIBUTE_TextEntry, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetChoiceListOpen() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_Open);
   return GetAttributeDefaultValue_Enum(XFA_Element::ChoiceList,
                                        XFA_ATTRIBUTE_Open, XFA_XDPPACKET_Form);
 }
 
-FX_BOOL CXFA_WidgetData::IsListBox() {
+bool CXFA_WidgetData::IsListBox() {
   int32_t iOpenMode = GetChoiceListOpen();
   return (iOpenMode == XFA_ATTRIBUTEENUM_Always ||
           iOpenMode == XFA_ATTRIBUTEENUM_MultiSelect);
 }
 
-int32_t CXFA_WidgetData::CountChoiceListItems(FX_BOOL bSaveValue) {
+int32_t CXFA_WidgetData::CountChoiceListItems(bool bSaveValue) {
   CXFA_NodeArray pItems;
   CXFA_Node* pItem = nullptr;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItems.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
     return 0;
 
   pItem = pItems[0];
   if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
     if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave)
       pItem = pItems[1];
   }
   pItems.RemoveAll();
   return pItem->CountChildren(XFA_Element::Unknown);
 }
 
-FX_BOOL CXFA_WidgetData::GetChoiceListItem(CFX_WideString& wsText,
-                                           int32_t nIndex,
-                                           FX_BOOL bSaveValue) {
+bool CXFA_WidgetData::GetChoiceListItem(CFX_WideString& wsText,
+                                        int32_t nIndex,
+                                        bool bSaveValue) {
   wsText.clear();
   CXFA_NodeArray pItemsArray;
   CXFA_Node* pItems = nullptr;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItemsArray.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
-    return FALSE;
+    return false;
 
   pItems = pItemsArray[0];
   if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItemsArray[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItemsArray[1]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemOneHasSave = pItemsArray[0]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemTwoHasSave = pItemsArray[1]->GetBoolean(XFA_ATTRIBUTE_Save);
     if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave)
       pItems = pItemsArray[1];
   }
   if (pItems) {
     CXFA_Node* pItem = pItems->GetChild(nIndex, XFA_Element::Unknown);
     if (pItem) {
       pItem->TryContent(wsText);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_WidgetData::GetChoiceListItems(CFX_WideStringArray& wsTextArray,
-                                         FX_BOOL bSaveValue) {
+                                         bool bSaveValue) {
   CXFA_NodeArray pItems;
   CXFA_Node* pItem = nullptr;
   int32_t iCount = 0;
   CXFA_Node* pNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() != XFA_Element::Items)
       continue;
 
     iCount++;
     pItems.Add(pNode);
     if (iCount == 2)
       break;
   }
   if (iCount == 0)
     return;
 
   pItem = pItems[0];
   if (iCount > 1) {
-    FX_BOOL bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
-    FX_BOOL bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemOneHasSave = pItems[0]->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bItemTwoHasSave = pItems[1]->GetBoolean(XFA_ATTRIBUTE_Save);
     if (bItemOneHasSave != bItemTwoHasSave && bSaveValue == bItemTwoHasSave)
       pItem = pItems[1];
   }
   pItems.RemoveAll();
   pNode = pItem->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling))
     pNode->TryContent(wsTextArray.Add());
 }
 
 int32_t CXFA_WidgetData::CountSelectedItems() {
   CFX_WideStringArray wsValueArray;
   GetSelectedItemsValue(wsValueArray);
   if (IsListBox() || !IsChoiceListAllowTextEntry())
     return wsValueArray.GetSize();
 
   int32_t iSelected = 0;
   CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
+  GetChoiceListItems(wsSaveTextArray, true);
   int32_t iValues = wsValueArray.GetSize();
   for (int32_t i = 0; i < iValues; i++) {
     int32_t iSaves = wsSaveTextArray.GetSize();
     for (int32_t j = 0; j < iSaves; j++) {
       if (wsValueArray[i] == wsSaveTextArray[j]) {
         iSelected++;
         break;
       }
     }
   }
   return iSelected;
 }
 
 int32_t CXFA_WidgetData::GetSelectedItem(int32_t nIndex) {
   CFX_WideStringArray wsValueArray;
   GetSelectedItemsValue(wsValueArray);
   CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
+  GetChoiceListItems(wsSaveTextArray, true);
   int32_t iSaves = wsSaveTextArray.GetSize();
   for (int32_t j = 0; j < iSaves; j++) {
     if (wsValueArray[nIndex] == wsSaveTextArray[j])
       return j;
   }
   return -1;
 }
 
 void CXFA_WidgetData::GetSelectedItems(CFX_Int32Array& iSelArray) {
   CFX_WideStringArray wsValueArray;
   GetSelectedItemsValue(wsValueArray);
   int32_t iValues = wsValueArray.GetSize();
   if (iValues < 1)
     return;
 
   CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
+  GetChoiceListItems(wsSaveTextArray, true);
   int32_t iSaves = wsSaveTextArray.GetSize();
   for (int32_t i = 0; i < iValues; i++) {
     for (int32_t j = 0; j < iSaves; j++) {
       if (wsValueArray[i] == wsSaveTextArray[j]) {
         iSelArray.Add(j);
         break;
       }
     }
   }
 }
@@ skipping 16 matching lines @@
         iEnd = wsValue.Find(L'\n', iStart);
         if (iEnd < 0)
           wsSelTextArray.Add(wsValue.Mid(iStart, iLength - iStart));
       }
     }
   } else {
     wsSelTextArray.Add(wsValue);
   }
 }
 
-FX_BOOL CXFA_WidgetData::GetItemState(int32_t nIndex) {
+bool CXFA_WidgetData::GetItemState(int32_t nIndex) {
   if (nIndex < 0)
-    return FALSE;
+    return false;
 
   CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
+  GetChoiceListItems(wsSaveTextArray, true);
   if (wsSaveTextArray.GetSize() <= nIndex)
-    return FALSE;
+    return false;
 
   CFX_WideStringArray wsValueArray;
   GetSelectedItemsValue(wsValueArray);
   int32_t iValues = wsValueArray.GetSize();
   for (int32_t j = 0; j < iValues; j++) {
     if (wsValueArray[j] == wsSaveTextArray[nIndex])
-      return TRUE;
+      return true;
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_WidgetData::SetItemState(int32_t nIndex,
-                                   FX_BOOL bSelected,
+                                   bool bSelected,
                                    bool bNotify,
-                                   FX_BOOL bScriptModify,
-                                   FX_BOOL bSyncData) {
+                                   bool bScriptModify,
+                                   bool bSyncData) {
   if (nIndex < 0)
     return;
 
   CFX_WideStringArray wsSaveTextArray;
-  GetChoiceListItems(wsSaveTextArray, TRUE);
+  GetChoiceListItems(wsSaveTextArray, true);
   if (wsSaveTextArray.GetSize() <= nIndex)
     return;
 
   int32_t iSel = -1;
   CFX_WideStringArray wsValueArray;
   GetSelectedItemsValue(wsValueArray);
   int32_t iValues = wsValueArray.GetSize();
   for (int32_t j = 0; j < iValues; j++) {
     if (wsValueArray[j] == wsSaveTextArray[nIndex]) {
       iSel = j;
@@ skipping 33 matching lines @@
       }
     } else if (iSel >= 0) {
       m_pNode->SetContent(CFX_WideString(), CFX_WideString(), bNotify,
                           bScriptModify, bSyncData);
     }
   }
 }
 
 void CXFA_WidgetData::SetSelectedItems(CFX_Int32Array& iSelArray,
                                        bool bNotify,
-                                       FX_BOOL bScriptModify,
-                                       FX_BOOL bSyncData) {
+                                       bool bScriptModify,
+                                       bool bSyncData) {
   CFX_WideString wsValue;
   int32_t iSize = iSelArray.GetSize();
   if (iSize >= 1) {
     CFX_WideStringArray wsSaveTextArray;
-    GetChoiceListItems(wsSaveTextArray, TRUE);
+    GetChoiceListItems(wsSaveTextArray, true);
     CFX_WideString wsItemValue;
     for (int32_t i = 0; i < iSize; i++) {
       wsItemValue = (iSize == 1)
                         ? wsSaveTextArray[iSelArray[i]]
                         : wsSaveTextArray[iSelArray[i]] + FX_WSTRC(L"\n");
       wsValue += wsItemValue;
     }
   }
   CFX_WideString wsFormat(wsValue);
   if (GetChoiceListOpen() != XFA_ATTRIBUTEENUM_MultiSelect)
     GetFormatDataValue(wsValue, wsFormat);
 
   m_pNode->SetContent(wsValue, wsFormat, bNotify, bScriptModify, bSyncData);
 }
 
 void CXFA_WidgetData::ClearAllSelections() {
   CXFA_Node* pBind = m_pNode->GetBindData();
   if (!pBind || GetChoiceListOpen() != XFA_ATTRIBUTEENUM_MultiSelect) {
     SyncValue(CFX_WideString(), false);
     return;
   }
 
   while (CXFA_Node* pChildNode = pBind->GetNodeItem(XFA_NODEITEM_FirstChild))
     pBind->RemoveChild(pChildNode);
 }
 
 void CXFA_WidgetData::InsertItem(const CFX_WideString& wsLabel,
                                  const CFX_WideString& wsValue,
                                  int32_t nIndex,
-                                 FX_BOOL bNotify) {
+                                 bool bNotify) {
   CFX_WideString wsNewValue(wsValue);
   if (wsNewValue.IsEmpty())
     wsNewValue = wsLabel;
 
   CXFA_NodeArray listitems;
   int32_t iCount = 0;
   CXFA_Node* pItemNode = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItemNode;
        pItemNode = pItemNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pItemNode->GetElementType() != XFA_Element::Items)
       continue;
 
     listitems.Add(pItemNode);
     iCount++;
   }
   if (iCount < 1) {
     CXFA_Node* pItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pItems);
     InsertListTextItem(pItems, wsLabel, nIndex);
     CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pSaveItems);
-    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
+    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, true);
     InsertListTextItem(pSaveItems, wsNewValue, nIndex);
   } else if (iCount > 1) {
     for (int32_t i = 0; i < 2; i++) {
       CXFA_Node* pNode = listitems[i];
-      FX_BOOL bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);
+      bool bHasSave = pNode->GetBoolean(XFA_ATTRIBUTE_Save);
       if (bHasSave)
         InsertListTextItem(pNode, wsNewValue, nIndex);
       else
         InsertListTextItem(pNode, wsLabel, nIndex);
     }
   } else {
     CXFA_Node* pNode = listitems[0];
-    pNode->SetBoolean(XFA_ATTRIBUTE_Save, FALSE);
+    pNode->SetBoolean(XFA_ATTRIBUTE_Save, false);
     pNode->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Visible);
     CXFA_Node* pSaveItems = m_pNode->CreateSamePacketNode(XFA_Element::Items);
     m_pNode->InsertChild(-1, pSaveItems);
-    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, TRUE);
+    pSaveItems->SetBoolean(XFA_ATTRIBUTE_Save, true);
     pSaveItems->SetEnum(XFA_ATTRIBUTE_Presence, XFA_ATTRIBUTEENUM_Hidden);
     listitems.RemoveAll();
     CXFA_Node* pListNode = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
     int32_t i = 0;
     while (pListNode) {
       CFX_WideString wsOldValue;
       pListNode->TryContent(wsOldValue);
       InsertListTextItem(pSaveItems, wsOldValue, i);
       i++;
       pListNode = pListNode->GetNodeItem(XFA_NODEITEM_NextSibling);
@@ skipping 17 matching lines @@
     if (pItems->GetElementType() != XFA_Element::Items)
       continue;
 
     iCount++;
     listitems.Add(pItems);
   }
   if (iCount <= 1) {
     wsLabel = wsValue;
   } else {
     CXFA_Node* pLabelItems = listitems[0];
-    FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
     CXFA_Node* pSaveItems = nullptr;
     if (bSave) {
       pSaveItems = pLabelItems;
       pLabelItems = listitems[1];
     } else {
       pSaveItems = listitems[1];
     }
     iCount = 0;
     int32_t iSearch = -1;
     CFX_WideString wsContent;
@@ skipping 25 matching lines @@
     if (pItems->GetElementType() != XFA_Element::Items)
       continue;
 
     iCount++;
     listitems.Add(pItems);
   }
   if (iCount <= 1) {
     wsValue = wsLabel;
   } else {
     CXFA_Node* pLabelItems = listitems[0];
-    FX_BOOL bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
+    bool bSave = pLabelItems->GetBoolean(XFA_ATTRIBUTE_Save);
     CXFA_Node* pSaveItems = nullptr;
     if (bSave) {
       pSaveItems = pLabelItems;
       pLabelItems = listitems[1];
     } else {
       pSaveItems = listitems[1];
     }
     iCount = 0;
     int32_t iSearch = -1;
     CFX_WideString wsContent;
     CXFA_Node* pChildItem = pLabelItems->GetNodeItem(XFA_NODEITEM_FirstChild);
     for (; pChildItem;
          pChildItem = pChildItem->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pChildItem->TryContent(wsContent);
       if (wsContent == wsLabel) {
         iSearch = iCount;
         break;
       }
       iCount++;
     }
     if (iSearch < 0)
       return;
     if (CXFA_Node* pText = pSaveItems->GetChild(iSearch, XFA_Element::Unknown))
       pText->TryContent(wsValue);
   }
 }
 
-FX_BOOL CXFA_WidgetData::DeleteItem(int32_t nIndex,
-                                    FX_BOOL bNotify,
-                                    FX_BOOL bScriptModify,
-                                    FX_BOOL bSyncData) {
-  FX_BOOL bSetValue = FALSE;
+bool CXFA_WidgetData::DeleteItem(int32_t nIndex,
+                                 bool bNotify,
+                                 bool bScriptModify,
+                                 bool bSyncData) {
+  bool bSetValue = false;
   CXFA_Node* pItems = m_pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pItems; pItems = pItems->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pItems->GetElementType() != XFA_Element::Items)
       continue;
 
     if (nIndex < 0) {
       while (CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild)) {
         pItems->RemoveChild(pNode);
       }
     } else {
       if (!bSetValue && pItems->GetBoolean(XFA_ATTRIBUTE_Save)) {
-        SetItemState(nIndex, FALSE, true, bScriptModify, bSyncData);
-        bSetValue = TRUE;
+        SetItemState(nIndex, false, true, bScriptModify, bSyncData);
+        bSetValue = true;
       }
       int32_t i = 0;
       CXFA_Node* pNode = pItems->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pNode) {
         if (i == nIndex) {
           pItems->RemoveChild(pNode);
           break;
         }
         i++;
         pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       }
     }
   }
   if (bNotify)
     m_pNode->GetDocument()->GetNotify()->OnWidgetListItemRemoved(this, nIndex);
-  return TRUE;
+  return true;
 }
 
 int32_t CXFA_WidgetData::GetHorizontalScrollPolicy() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetEnum(XFA_ATTRIBUTE_HScrollPolicy);
   return XFA_ATTRIBUTEENUM_Auto;
 }
 
 int32_t CXFA_WidgetData::GetNumberOfCells() {
   CXFA_Node* pUIChild = GetUIChild();
   if (!pUIChild)
     return -1;
   if (CXFA_Node* pNode = pUIChild->GetChild(0, XFA_Element::Comb))
     return pNode->GetInteger(XFA_ATTRIBUTE_NumberOfCells);
   return -1;
 }
 
 CFX_WideString CXFA_WidgetData::GetBarcodeType() {
   CXFA_Node* pUIChild = GetUIChild();
   return pUIChild ? CFX_WideString(pUIChild->GetCData(XFA_ATTRIBUTE_Type))
                   : CFX_WideString();
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_CharEncoding(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_CharEncoding(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideString wsCharEncoding;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_CharEncoding, wsCharEncoding)) {
     if (wsCharEncoding.CompareNoCase(L"UTF-16")) {
       val = CHAR_ENCODING_UNICODE;
-      return TRUE;
+      return true;
     }
     if (wsCharEncoding.CompareNoCase(L"UTF-8")) {
       val = CHAR_ENCODING_UTF8;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Checksum(FX_BOOL& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_Checksum(bool& val) {
   CXFA_Node* pUIChild = GetUIChild();
   XFA_ATTRIBUTEENUM eChecksum;
   if (pUIChild->TryEnum(XFA_ATTRIBUTE_Checksum, eChecksum)) {
     switch (eChecksum) {
       case XFA_ATTRIBUTEENUM_None:
         val = false;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_Auto:
         val = true;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_1mod10:
         break;
       case XFA_ATTRIBUTEENUM_1mod10_1mod11:
         break;
       case XFA_ATTRIBUTEENUM_2mod10:
         break;
       default:
         break;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_DataLength(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_DataLength(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideString wsDataLength;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_DataLength, wsDataLength)) {
     val = FXSYS_wtoi(wsDataLength.c_str());
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_StartChar(FX_CHAR& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_StartChar(FX_CHAR& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideStringC wsStartEndChar;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_StartChar, wsStartEndChar)) {
     if (wsStartEndChar.GetLength()) {
       val = (FX_CHAR)wsStartEndChar.GetAt(0);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_EndChar(FX_CHAR& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_EndChar(FX_CHAR& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideStringC wsStartEndChar;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_EndChar, wsStartEndChar)) {
     if (wsStartEndChar.GetLength()) {
       val = (FX_CHAR)wsStartEndChar.GetAt(0);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ECLevel(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_ECLevel(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideString wsECLevel;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_ErrorCorrectionLevel, wsECLevel)) {
     val = FXSYS_wtoi(wsECLevel.c_str());
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleWidth(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_ModuleWidth(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CXFA_Measurement mModuleWidthHeight;
   if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleWidth, mModuleWidthHeight)) {
     val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_ModuleHeight(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_ModuleHeight(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CXFA_Measurement mModuleWidthHeight;
   if (pUIChild->TryMeasure(XFA_ATTRIBUTE_ModuleHeight, mModuleWidthHeight)) {
     val = (int32_t)mModuleWidthHeight.ToUnit(XFA_UNIT_Pt);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_PrintChecksum(FX_BOOL& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_PrintChecksum(bool& val) {
   CXFA_Node* pUIChild = GetUIChild();
-  FX_BOOL bPrintCheckDigit;
+  bool bPrintCheckDigit;
   if (pUIChild->TryBoolean(XFA_ATTRIBUTE_PrintCheckDigit, bPrintCheckDigit)) {
     val = bPrintCheckDigit;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_TextLocation(int32_t& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_TextLocation(int32_t& val) {
   CXFA_Node* pUIChild = GetUIChild();
   XFA_ATTRIBUTEENUM eTextLocation;
   if (pUIChild->TryEnum(XFA_ATTRIBUTE_TextLocation, eTextLocation)) {
     switch (eTextLocation) {
       case XFA_ATTRIBUTEENUM_None:
         val = BC_TEXT_LOC_NONE;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_Above:
         val = BC_TEXT_LOC_ABOVE;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_Below:
         val = BC_TEXT_LOC_BELOW;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_AboveEmbedded:
         val = BC_TEXT_LOC_ABOVEEMBED;
-        return TRUE;
+        return true;
       case XFA_ATTRIBUTEENUM_BelowEmbedded:
         val = BC_TEXT_LOC_BELOWEMBED;
-        return TRUE;
+        return true;
       default:
         break;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_Truncate(FX_BOOL& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_Truncate(bool& val) {
   CXFA_Node* pUIChild = GetUIChild();
-  FX_BOOL bTruncate;
+  bool bTruncate;
   if (pUIChild->TryBoolean(XFA_ATTRIBUTE_Truncate, bTruncate)) {
     val = bTruncate;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetBarcodeAttribute_WideNarrowRatio(FX_FLOAT& val) {
+bool CXFA_WidgetData::GetBarcodeAttribute_WideNarrowRatio(FX_FLOAT& val) {
   CXFA_Node* pUIChild = GetUIChild();
   CFX_WideString wsWideNarrowRatio;
   if (pUIChild->TryCData(XFA_ATTRIBUTE_WideNarrowRatio, wsWideNarrowRatio)) {
     FX_STRSIZE ptPos = wsWideNarrowRatio.Find(':');
     FX_FLOAT fRatio = 0;
     if (ptPos >= 0) {
       fRatio = (FX_FLOAT)FXSYS_wtoi(wsWideNarrowRatio.c_str());
     } else {
       int32_t fA, fB;
       fA = FXSYS_wtoi(wsWideNarrowRatio.Left(ptPos).c_str());
       fB = FXSYS_wtoi(wsWideNarrowRatio.Mid(ptPos + 1).c_str());
       if (fB)
         fRatio = (FX_FLOAT)fA / fB;
     }
     val = fRatio;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_WidgetData::GetPasswordChar(CFX_WideString& wsPassWord) {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild) {
     pUIChild->TryCData(XFA_ATTRIBUTE_PasswordChar, wsPassWord);
   } else {
     wsPassWord = GetAttributeDefaultValue_Cdata(XFA_Element::PasswordEdit,
                                                 XFA_ATTRIBUTE_PasswordChar,
                                                 XFA_XDPPACKET_Form);
   }
 }
 
-FX_BOOL CXFA_WidgetData::IsMultiLine() {
+bool CXFA_WidgetData::IsMultiLine() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
     return pUIChild->GetBoolean(XFA_ATTRIBUTE_MultiLine);
   return GetAttributeDefaultValue_Boolean(
       XFA_Element::TextEdit, XFA_ATTRIBUTE_MultiLine, XFA_XDPPACKET_Form);
 }
 
 int32_t CXFA_WidgetData::GetVerticalScrollPolicy() {
   CXFA_Node* pUIChild = GetUIChild();
   if (pUIChild)
@@ skipping 15 matching lines @@
           return iMax < 0 ? 0 : iMax;
         }
         default:
           break;
       }
     }
   }
   return 0;
 }
 
-FX_BOOL CXFA_WidgetData::GetFracDigits(int32_t& iFracDigits) {
+bool CXFA_WidgetData::GetFracDigits(int32_t& iFracDigits) {
   if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_Element::Value)) {
     if (CXFA_Node* pChild = pNode->GetChild(0, XFA_Element::Decimal))
       return pChild->TryInteger(XFA_ATTRIBUTE_FracDigits, iFracDigits);
   }
   iFracDigits = -1;
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetLeadDigits(int32_t& iLeadDigits) {
+bool CXFA_WidgetData::GetLeadDigits(int32_t& iLeadDigits) {
   if (CXFA_Node* pNode = m_pNode->GetChild(0, XFA_Element::Value)) {
     if (CXFA_Node* pChild = pNode->GetChild(0, XFA_Element::Decimal))
       return pChild->TryInteger(XFA_ATTRIBUTE_LeadDigits, iLeadDigits);
   }
   iLeadDigits = -1;
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::SetValue(const CFX_WideString& wsValue,
-                                  XFA_VALUEPICTURE eValueType) {
+bool CXFA_WidgetData::SetValue(const CFX_WideString& wsValue,
+                               XFA_VALUEPICTURE eValueType) {
   if (wsValue.IsEmpty()) {
     SyncValue(wsValue, true);
-    return TRUE;
+    return true;
   }
   m_bPreNull = m_bIsNull;
-  m_bIsNull = FALSE;
+  m_bIsNull = false;
   CFX_WideString wsNewText(wsValue);
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, eValueType);
-  FX_BOOL bValidate = TRUE;
-  FX_BOOL bSyncData = FALSE;
+  bool bValidate = true;
+  bool bSyncData = false;
   CXFA_Node* pNode = GetUIChild();
   if (!pNode)
-    return TRUE;
+    return true;
 
   XFA_Element eType = pNode->GetElementType();
   if (!wsPicture.IsEmpty()) {
     CXFA_LocaleMgr* pLocalMgr = m_pNode->GetDocument()->GetLocalMgr();
     IFX_Locale* pLocale = GetLocal();
     CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
     bValidate =
         widgetValue.ValidateValue(wsValue, wsPicture, pLocale, &wsPicture);
     if (bValidate) {
       widgetValue = CXFA_LocaleValue(widgetValue.GetType(), wsNewText,
                                      wsPicture, pLocale, pLocalMgr);
       wsNewText = widgetValue.GetValue();
       if (eType == XFA_Element::NumericEdit) {
         int32_t iLeadDigits = 0;
         int32_t iFracDigits = 0;
         GetLeadDigits(iLeadDigits);
         GetFracDigits(iFracDigits);
         wsNewText = NumericLimit(wsNewText, iLeadDigits, iFracDigits);
       }
-      bSyncData = TRUE;
+      bSyncData = true;
     }
   } else {
     if (eType == XFA_Element::NumericEdit) {
       if (wsNewText != FX_WSTRC(L"0")) {
         int32_t iLeadDigits = 0;
         int32_t iFracDigits = 0;
         GetLeadDigits(iLeadDigits);
         GetFracDigits(iFracDigits);
         wsNewText = NumericLimit(wsNewText, iLeadDigits, iFracDigits);
       }
-      bSyncData = TRUE;
+      bSyncData = true;
     }
   }
   if (eType != XFA_Element::NumericEdit || bSyncData)
     SyncValue(wsNewText, true);
 
   return bValidate;
 }
 
-FX_BOOL CXFA_WidgetData::GetPictureContent(CFX_WideString& wsPicture,
-                                           XFA_VALUEPICTURE ePicture) {
+bool CXFA_WidgetData::GetPictureContent(CFX_WideString& wsPicture,
+                                        XFA_VALUEPICTURE ePicture) {
   if (ePicture == XFA_VALUEPICTURE_Raw)
-    return FALSE;
+    return false;
 
   CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
   switch (ePicture) {
     case XFA_VALUEPICTURE_Display: {
       if (CXFA_Node* pFormat = m_pNode->GetChild(0, XFA_Element::Format)) {
         if (CXFA_Node* pPicture = pFormat->GetChild(0, XFA_Element::Picture)) {
           if (pPicture->TryContent(wsPicture))
-            return TRUE;
+            return true;
         }
       }
       CFX_WideString wsDataPicture, wsTimePicture;
       IFX_Locale* pLocale = GetLocal();
       if (!pLocale)
-        return FALSE;
+        return false;
 
       uint32_t dwType = widgetValue.GetType();
       switch (dwType) {
         case XFA_VT_DATE:
           pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
                                   wsPicture);
           break;
         case XFA_VT_TIME:
           pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
                                   wsPicture);
           break;
         case XFA_VT_DATETIME:
           pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
                                   wsDataPicture);
           pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Medium,
                                   wsTimePicture);
           wsPicture = wsDataPicture + FX_WSTRC(L"T") + wsTimePicture;
           break;
         case XFA_VT_DECIMAL:
         case XFA_VT_FLOAT:
           break;
         default:
           break;
       }
-      return TRUE;
+      return true;
     }
 
     case XFA_VALUEPICTURE_Edit: {
       CXFA_Node* pUI = m_pNode->GetChild(0, XFA_Element::Ui);
       if (pUI) {
         if (CXFA_Node* pPicture = pUI->GetChild(0, XFA_Element::Picture)) {
           if (pPicture->TryContent(wsPicture))
-            return TRUE;
+            return true;
         }
       }
       {
         CFX_WideString wsDataPicture, wsTimePicture;
         IFX_Locale* pLocale = GetLocal();
         if (!pLocale) {
-          return FALSE;
+          return false;
         }
         uint32_t dwType = widgetValue.GetType();
         switch (dwType) {
           case XFA_VT_DATE:
             pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
                                     wsPicture);
             break;
           case XFA_VT_TIME:
             pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
                                     wsPicture);
             break;
           case XFA_VT_DATETIME:
             pLocale->GetDatePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
                                     wsDataPicture);
             pLocale->GetTimePattern(FX_LOCALEDATETIMESUBCATEGORY_Short,
                                     wsTimePicture);
             wsPicture = wsDataPicture + L"T" + wsTimePicture;
             break;
           default:
             break;
         }
       }
-      return TRUE;
+      return true;
     }
     case XFA_VALUEPICTURE_DataBind: {
       if (CXFA_Bind bind = GetBind()) {
         bind.GetPicture(wsPicture);
-        return TRUE;
+        return true;
       }
       break;
     }
     default:
       break;
   }
-  return FALSE;
+  return false;
 }
 
 IFX_Locale* CXFA_WidgetData::GetLocal() {
   if (!m_pNode)
     return nullptr;
 
   CFX_WideString wsLocaleName;
   if (!m_pNode->GetLocaleName(wsLocaleName))
     return nullptr;
   if (wsLocaleName == FX_WSTRC(L"ambient"))
     return m_pNode->GetDocument()->GetLocalMgr()->GetDefLocale();
   return m_pNode->GetDocument()->GetLocalMgr()->GetLocaleByName(wsLocaleName);
 }
 
-FX_BOOL CXFA_WidgetData::GetValue(CFX_WideString& wsValue,
-                                  XFA_VALUEPICTURE eValueType) {
+bool CXFA_WidgetData::GetValue(CFX_WideString& wsValue,
+                               XFA_VALUEPICTURE eValueType) {
   wsValue = m_pNode->GetContent();
 
   if (eValueType == XFA_VALUEPICTURE_Display)
     GetItemLabel(wsValue.AsStringC(), wsValue);
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, eValueType);
   CXFA_Node* pNode = GetUIChild();
   if (!pNode)
-    return TRUE;
+    return true;
 
   switch (GetUIChild()->GetElementType()) {
     case XFA_Element::ChoiceList: {
       if (eValueType == XFA_VALUEPICTURE_Display) {
         int32_t iSelItemIndex = GetSelectedItem(0);
         if (iSelItemIndex >= 0) {
           GetChoiceListItem(wsValue, iSelItemIndex);
           wsPicture.clear();
         }
       }
     } break;
     case XFA_Element::NumericEdit:
       if (eValueType != XFA_VALUEPICTURE_Raw && wsPicture.IsEmpty()) {
         IFX_Locale* pLocale = GetLocal();
         if (eValueType == XFA_VALUEPICTURE_Display && pLocale) {
           CFX_WideString wsOutput;
           NormalizeNumStr(wsValue, wsOutput);
           FormatNumStr(wsOutput, pLocale, wsOutput);
           wsValue = wsOutput;
         }
       }
       break;
     default:
       break;
   }
   if (wsPicture.IsEmpty())
-    return TRUE;
+    return true;
 
   if (IFX_Locale* pLocale = GetLocal()) {
     CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
     CXFA_LocaleMgr* pLocalMgr = m_pNode->GetDocument()->GetLocalMgr();
     switch (widgetValue.GetType()) {
       case XFA_VT_DATE: {
         CFX_WideString wsDate, wsTime;
         if (SplitDateTime(wsValue, wsDate, wsTime)) {
           CXFA_LocaleValue date(XFA_VT_DATE, wsDate, pLocalMgr);
           if (date.FormatPatterns(wsValue, wsPicture, pLocale, eValueType))
-            return TRUE;
+            return true;
         }
         break;
       }
       case XFA_VT_TIME: {
         CFX_WideString wsDate, wsTime;
         if (SplitDateTime(wsValue, wsDate, wsTime)) {
           CXFA_LocaleValue time(XFA_VT_TIME, wsTime, pLocalMgr);
           if (time.FormatPatterns(wsValue, wsPicture, pLocale, eValueType))
-            return TRUE;
+            return true;
         }
         break;
       }
       default:
         break;
     }
     widgetValue.FormatPatterns(wsValue, wsPicture, pLocale, eValueType);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_WidgetData::GetNormalizeDataValue(
-    const CFX_WideString& wsValue,
-    CFX_WideString& wsNormalizeValue) {
+bool CXFA_WidgetData::GetNormalizeDataValue(const CFX_WideString& wsValue,
+                                            CFX_WideString& wsNormalizeValue) {
   wsNormalizeValue = wsValue;
   if (wsValue.IsEmpty())
-    return TRUE;
+    return true;
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
   if (wsPicture.IsEmpty())
-    return TRUE;
+    return true;
 
   ASSERT(GetNode());
   CXFA_LocaleMgr* pLocalMgr = GetNode()->GetDocument()->GetLocalMgr();
   IFX_Locale* pLocale = GetLocal();
   CXFA_LocaleValue widgetValue = XFA_GetLocaleValue(this);
   if (widgetValue.ValidateValue(wsValue, wsPicture, pLocale, &wsPicture)) {
     widgetValue = CXFA_LocaleValue(widgetValue.GetType(), wsNormalizeValue,
                                    wsPicture, pLocale, pLocalMgr);
     wsNormalizeValue = widgetValue.GetValue();
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_WidgetData::GetFormatDataValue(const CFX_WideString& wsValue,
-                                            CFX_WideString& wsFormattedValue) {
+bool CXFA_WidgetData::GetFormatDataValue(const CFX_WideString& wsValue,
+                                         CFX_WideString& wsFormattedValue) {
   wsFormattedValue = wsValue;
   if (wsValue.IsEmpty())
-    return TRUE;
+    return true;
 
   CFX_WideString wsPicture;
   GetPictureContent(wsPicture, XFA_VALUEPICTURE_DataBind);
   if (wsPicture.IsEmpty())
-    return TRUE;
+    return true;
 
   if (IFX_Locale* pLocale = GetLocal()) {
     ASSERT(GetNode());
     CXFA_Node* pNodeValue = GetNode()->GetChild(0, XFA_Element::Value);
     if (!pNodeValue)
-      return FALSE;
+      return false;
 
     CXFA_Node* pValueChild = pNodeValue->GetNodeItem(XFA_NODEITEM_FirstChild);
     if (!pValueChild)
-      return FALSE;
+      return false;
 
     int32_t iVTType = XFA_VT_NULL;
     switch (pValueChild->GetElementType()) {
       case XFA_Element::Decimal:
         iVTType = XFA_VT_DECIMAL;
         break;
       case XFA_Element::Float:
         iVTType = XFA_VT_FLOAT;
         break;
       case XFA_Element::Date:
@@ skipping 20 matching lines @@
     }
     CXFA_LocaleMgr* pLocalMgr = GetNode()->GetDocument()->GetLocalMgr();
     CXFA_LocaleValue widgetValue(iVTType, wsValue, pLocalMgr);
     switch (widgetValue.GetType()) {
       case XFA_VT_DATE: {
         CFX_WideString wsDate, wsTime;
         if (SplitDateTime(wsValue, wsDate, wsTime)) {
           CXFA_LocaleValue date(XFA_VT_DATE, wsDate, pLocalMgr);
           if (date.FormatPatterns(wsFormattedValue, wsPicture, pLocale,
                                   XFA_VALUEPICTURE_DataBind)) {
-            return TRUE;
+            return true;
           }
         }
         break;
       }
       case XFA_VT_TIME: {
         CFX_WideString wsDate, wsTime;
         if (SplitDateTime(wsValue, wsDate, wsTime)) {
           CXFA_LocaleValue time(XFA_VT_TIME, wsTime, pLocalMgr);
           if (time.FormatPatterns(wsFormattedValue, wsPicture, pLocale,
                                   XFA_VALUEPICTURE_DataBind)) {
-            return TRUE;
+            return true;
           }
         }
         break;
       }
       default:
         break;
     }
     widgetValue.FormatPatterns(wsFormattedValue, wsPicture, pLocale,
                                XFA_VALUEPICTURE_DataBind);
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_WidgetData::NormalizeNumStr(const CFX_WideString& wsValue,
                                       CFX_WideString& wsOutput) {
   if (wsValue.IsEmpty())
     return;
 
   wsOutput = wsValue;
   wsOutput.TrimLeft('0');
   int32_t dot_index = wsOutput.Find('.');
   int32_t iFracDigits = 0;
   if (!wsOutput.IsEmpty() && dot_index >= 0 &&
       (!GetFracDigits(iFracDigits) || iFracDigits != -1)) {
     wsOutput.TrimRight(L"0");
     wsOutput.TrimRight(L".");
   }
   if (wsOutput.IsEmpty() || wsOutput[0] == '.')
     wsOutput.Insert(0, '0');
 }
 
 void CXFA_WidgetData::FormatNumStr(const CFX_WideString& wsValue,
                                    IFX_Locale* pLocale,
                                    CFX_WideString& wsOutput) {
   if (wsValue.IsEmpty())
     return;
 
   CFX_WideString wsSrcNum = wsValue;
   CFX_WideString wsGroupSymbol;
   pLocale->GetNumbericSymbol(FX_LOCALENUMSYMBOL_Grouping, wsGroupSymbol);
-  FX_BOOL bNeg = FALSE;
+  bool bNeg = false;
   if (wsSrcNum[0] == '-') {
-    bNeg = TRUE;
+    bNeg = true;
     wsSrcNum.Delete(0, 1);
   }
   int32_t len = wsSrcNum.GetLength();
   int32_t dot_index = wsSrcNum.Find('.');
   if (dot_index == -1)
     dot_index = len;
 
   int32_t cc = dot_index - 1;
   if (cc >= 0) {
     int nPos = dot_index % 3;
@@ skipping 28 matching lines @@
     pContainerWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
 
   m_pNode->SetContent(wsValue, wsFormatValue, bNotify);
 }
 
 void CXFA_WidgetData::InsertListTextItem(CXFA_Node* pItems,
                                          const CFX_WideString& wsText,
                                          int32_t nIndex) {
   CXFA_Node* pText = pItems->CreateSamePacketNode(XFA_Element::Text);
   pItems->InsertChild(nIndex, pText);
-  pText->SetContent(wsText, wsText, FALSE, FALSE, FALSE);
+  pText->SetContent(wsText, wsText, false, false, false);
 }
 
 CFX_WideString CXFA_WidgetData::NumericLimit(const CFX_WideString& wsValue,
                                              int32_t iLead,
                                              int32_t iTread) const {
   if ((iLead == -1) && (iTread == -1))
     return wsValue;
 
   CFX_WideString wsRet;
   int32_t iLead_ = 0, iTread_ = -1;
@@ skipping 25 matching lines @@
         }
       }
     } else if (wc == L'.') {
       iTread_ = 0;
       iLead = -1;
     }
     wsRet += wc;
   }
   return wsRet;
 }