Remove FX_BOOL from xfa.

xfa/fxfa/parser/cxfa_node.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/xfa_object.h"
 
 #include <map>
 #include <memory>
@@ skipping 109 matching lines @@
 
   CXFA_NodeSetPairMap* pNodeSetPairMap = (*pMap)[pParentNode].get();
   if (!(*pNodeSetPairMap)[dwNameHash])
     (*pNodeSetPairMap)[dwNameHash].reset(new CXFA_NodeSetPair);
 
   return (*pNodeSetPairMap)[dwNameHash].get();
 }
 
 void ReorderDataNodes(const CXFA_NodeSet& sSet1,
                       const CXFA_NodeSet& sSet2,
-                      FX_BOOL bInsertBefore) {
+                      bool bInsertBefore) {
   CXFA_NodeSetPairMapMap rgMap;
   for (CXFA_Node* pNode : sSet1) {
     CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
     if (pNodeSetPair)
       pNodeSetPair->first.insert(pNode);
   }
   for (CXFA_Node* pNode : sSet2) {
     CXFA_NodeSetPair* pNodeSetPair = NodeSetPairForNode(pNode, &rgMap);
     if (pNodeSetPair) {
       if (pdfium::ContainsValue(pNodeSetPair->first, pNode))
@@ skipping 70 matching lines @@
     if (iCount > iIndex)
       return pNode;
   }
   return nullptr;
 }
 
 void InsertItem(CXFA_Node* pInstMgrNode,
                 CXFA_Node* pNewInstance,
                 int32_t iPos,
                 int32_t iCount = -1,
-                FX_BOOL bMoveDataBindingNodes = TRUE) {
+                bool bMoveDataBindingNodes = true) {
   if (iCount < 0)
     iCount = GetCount(pInstMgrNode);
   if (iPos < 0)
     iPos = iCount;
   if (iPos == iCount) {
     CXFA_Node* pNextSibling =
         iCount > 0
             ? GetItem(pInstMgrNode, iCount - 1)
                   ->GetNodeItem(XFA_NODEITEM_NextSibling)
             : pInstMgrNode->GetNodeItem(XFA_NODEITEM_NextSibling);
@@ skipping 17 matching lines @@
                                 CXFA_TraverseStrategy_XFAContainerNode>
           sIteratorAfter(pNextSibling);
       for (CXFA_Node* pNode = sIteratorAfter.GetCurrent(); pNode;
            pNode = sIteratorAfter.MoveToNext()) {
         CXFA_Node* pDataNode = pNode->GetBindData();
         if (!pDataNode)
           continue;
 
         sAfter.insert(pDataNode);
       }
-      ReorderDataNodes(sNew, sAfter, FALSE);
+      ReorderDataNodes(sNew, sAfter, false);
     }
   } else {
     CXFA_Node* pBeforeInstance = GetItem(pInstMgrNode, iPos);
     pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)
         ->InsertChild(pNewInstance, pBeforeInstance);
     if (bMoveDataBindingNodes) {
       CXFA_NodeSet sNew;
       CXFA_NodeSet sBefore;
       CXFA_NodeIteratorTemplate<CXFA_Node,
                                 CXFA_TraverseStrategy_XFAContainerNode>
@@ skipping 10 matching lines @@
                                 CXFA_TraverseStrategy_XFAContainerNode>
           sIteratorBefore(pBeforeInstance);
       for (CXFA_Node* pNode = sIteratorBefore.GetCurrent(); pNode;
            pNode = sIteratorBefore.MoveToNext()) {
         CXFA_Node* pDataNode = pNode->GetBindData();
         if (!pDataNode)
           continue;
 
         sBefore.insert(pDataNode);
       }
-      ReorderDataNodes(sNew, sBefore, TRUE);
+      ReorderDataNodes(sNew, sBefore, true);
     }
   }
 }
 
 void RemoveItem(CXFA_Node* pInstMgrNode,
                 CXFA_Node* pRemoveInstance,
-                FX_BOOL bRemoveDataBinding = TRUE) {
+                bool bRemoveDataBinding = true) {
   pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pRemoveInstance);
   if (!bRemoveDataBinding)
     return;
 
   CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFAContainerNode>
       sIterator(pRemoveInstance);
   for (CXFA_Node* pFormNode = sIterator.GetCurrent(); pFormNode;
        pFormNode = sIterator.MoveToNext()) {
     CXFA_Node* pDataNode = pFormNode->GetBindData();
     if (!pDataNode)
       continue;
 
     if (pDataNode->RemoveBindItem(pFormNode) == 0) {
       if (CXFA_Node* pDataParent =
               pDataNode->GetNodeItem(XFA_NODEITEM_Parent)) {
         pDataParent->RemoveChild(pDataNode);
       }
     }
     pFormNode->SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
   }
 }
 
-CXFA_Node* CreateInstance(CXFA_Node* pInstMgrNode, FX_BOOL bDataMerge) {
+CXFA_Node* CreateInstance(CXFA_Node* pInstMgrNode, bool bDataMerge) {
   CXFA_Document* pDocument = pInstMgrNode->GetDocument();
   CXFA_Node* pTemplateNode = pInstMgrNode->GetTemplateNode();
   CXFA_Node* pFormParent = pInstMgrNode->GetNodeItem(XFA_NODEITEM_Parent);
   CXFA_Node* pDataScope = nullptr;
   for (CXFA_Node* pRootBoundNode = pFormParent;
        pRootBoundNode && pRootBoundNode->IsContainerNode();
        pRootBoundNode = pRootBoundNode->GetNodeItem(XFA_NODEITEM_Parent)) {
     pDataScope = pRootBoundNode->GetBindData();
     if (pDataScope)
       break;
   }
   if (!pDataScope) {
     pDataScope = ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record));
     ASSERT(pDataScope);
   }
   CXFA_Node* pInstance = pDocument->DataMerge_CopyContainer(
-      pTemplateNode, pFormParent, pDataScope, TRUE, bDataMerge, TRUE);
+      pTemplateNode, pFormParent, pDataScope, true, bDataMerge, true);
   if (pInstance) {
     pDocument->DataMerge_UpdateBindingRelations(pInstance);
     pFormParent->RemoveChild(pInstance);
   }
   return pInstance;
 }
 
 struct XFA_ExecEventParaInfo {
  public:
   uint32_t m_uHash;
@@ skipping 156 matching lines @@
   while (pNode) {
     CXFA_Node* pNext = pNode->m_pNext;
     pNode->m_pParent = nullptr;
     delete pNode;
     pNode = pNext;
   }
   if (m_pXMLNode && IsOwnXMLNode())
     m_pXMLNode->Release();
 }
 
-CXFA_Node* CXFA_Node::Clone(FX_BOOL bRecursive) {
+CXFA_Node* CXFA_Node::Clone(bool bRecursive) {
   CXFA_Node* pClone = m_pDocument->CreateNode(m_ePacket, m_elementType);
   if (!pClone)
     return nullptr;
 
   MergeAllData(pClone);
   pClone->UpdateNameHash();
   if (IsNeedSavingXMLNode()) {
     CFDE_XMLNode* pCloneXML = nullptr;
     if (IsAttributeInXML()) {
       CFX_WideString wsName;
-      GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
+      GetAttribute(XFA_ATTRIBUTE_Name, wsName, false);
       CFDE_XMLElement* pCloneXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pCloneXMLElement->SetTextData(CFX_WideString(wsValue));
       }
       pCloneXML = pCloneXMLElement;
       pCloneXMLElement = nullptr;
       pClone->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
-      pCloneXML = m_pXMLNode->Clone(FALSE);
+      pCloneXML = m_pXMLNode->Clone(false);
     }
     pClone->SetXMLMappingNode(pCloneXML);
     pClone->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   if (bRecursive) {
     for (CXFA_Node* pChild = GetNodeItem(XFA_NODEITEM_FirstChild); pChild;
          pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       pClone->InsertChild(pChild->Clone(bRecursive));
     }
   }
@@ skipping 140 matching lines @@
   return nodes.GetSize();
 }
 
 CXFA_Node* CXFA_Node::CreateSamePacketNode(XFA_Element eType,
                                            uint32_t dwFlags) {
   CXFA_Node* pNode = m_pDocument->CreateNode(m_ePacket, eType);
   pNode->SetFlag(dwFlags, true);
   return pNode;
 }
 
-CXFA_Node* CXFA_Node::CloneTemplateToForm(FX_BOOL bRecursive) {
+CXFA_Node* CXFA_Node::CloneTemplateToForm(bool bRecursive) {
   ASSERT(m_ePacket == XFA_XDPPACKET_Template);
   CXFA_Node* pClone =
       m_pDocument->CreateNode(XFA_XDPPACKET_Form, m_elementType);
   if (!pClone)
     return nullptr;
 
   pClone->SetTemplateNode(this);
   pClone->UpdateNameHash();
   pClone->SetXMLMappingNode(GetXMLMappingNode());
   if (bRecursive) {
@@ skipping 82 matching lines @@
   }
   CXFA_Node* pOldFormItem =
       static_cast<CXFA_Node*>(GetObject(XFA_ATTRIBUTE_BindingNode));
   if (pOldFormItem == pFormNode) {
     SetObject(XFA_ATTRIBUTE_BindingNode, nullptr);
     pOldFormItem = nullptr;
   }
   return pOldFormItem ? 1 : 0;
 }
 
-FX_BOOL CXFA_Node::HasBindItem() {
+bool CXFA_Node::HasBindItem() {
   return GetPacketID() == XFA_XDPPACKET_Datasets &&
          GetObject(XFA_ATTRIBUTE_BindingNode);
 }
 
 CXFA_WidgetData* CXFA_Node::GetWidgetData() {
   return (CXFA_WidgetData*)GetObject(XFA_ATTRIBUTE_WidgetData);
 }
 
 CXFA_WidgetData* CXFA_Node::GetContainerWidgetData() {
   if (GetPacketID() != XFA_XDPPACKET_Form)
@@ skipping 52 matching lines @@
         (pGrandNode && pGrandNode->GetElementType() == XFA_Element::Value)
             ? pGrandNode
             : nullptr;
   }
   CXFA_Node* pParentOfValueNode =
       pValueNode ? pValueNode->GetNodeItem(XFA_NODEITEM_Parent) : nullptr;
   return pParentOfValueNode ? pParentOfValueNode->GetContainerWidgetData()
                             : nullptr;
 }
 
-FX_BOOL CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
+bool CXFA_Node::GetLocaleName(CFX_WideString& wsLocaleName) {
   CXFA_Node* pForm = GetDocument()->GetXFAObject(XFA_HASHCODE_Form)->AsNode();
   CXFA_Node* pTopSubform = pForm->GetFirstChildByClass(XFA_Element::Subform);
   ASSERT(pTopSubform);
   CXFA_Node* pLocaleNode = this;
-  FX_BOOL bLocale = FALSE;
+  bool bLocale = false;
   do {
-    bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE);
+    bLocale = pLocaleNode->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, false);
     if (!bLocale) {
       pLocaleNode = pLocaleNode->GetNodeItem(XFA_NODEITEM_Parent);
     }
   } while (pLocaleNode && pLocaleNode != pTopSubform && !bLocale);
   if (bLocale)
-    return TRUE;
+    return true;
   CXFA_Node* pConfig = ToNode(GetDocument()->GetXFAObject(XFA_HASHCODE_Config));
   wsLocaleName = GetDocument()->GetLocalMgr()->GetConfigLocaleName(pConfig);
   if (!wsLocaleName.IsEmpty())
-    return TRUE;
+    return true;
   if (pTopSubform &&
-      pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, FALSE)) {
-    return TRUE;
+      pTopSubform->TryCData(XFA_ATTRIBUTE_Locale, wsLocaleName, false)) {
+    return true;
   }
   IFX_Locale* pLocale = GetDocument()->GetLocalMgr()->GetDefLocale();
   if (pLocale) {
     wsLocaleName = pLocale->GetName();
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 XFA_ATTRIBUTEENUM CXFA_Node::GetIntact() {
   CXFA_Node* pKeep = GetFirstChildByClass(XFA_Element::Keep);
   XFA_ATTRIBUTEENUM eLayoutType = GetEnum(XFA_ATTRIBUTE_Layout);
   if (pKeep) {
     XFA_ATTRIBUTEENUM eIntact;
-    if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, FALSE)) {
+    if (pKeep->TryEnum(XFA_ATTRIBUTE_Intact, eIntact, false)) {
       if (eIntact == XFA_ATTRIBUTEENUM_None &&
           eLayoutType == XFA_ATTRIBUTEENUM_Row &&
           m_pDocument->GetCurVersionMode() < XFA_VERSION_208) {
         CXFA_Node* pPreviewRow = GetNodeItem(XFA_NODEITEM_PrevSibling,
                                              XFA_ObjectType::ContainerNode);
         if (pPreviewRow &&
             pPreviewRow->GetEnum(XFA_ATTRIBUTE_Layout) ==
                 XFA_ATTRIBUTEENUM_Row) {
           XFA_ATTRIBUTEENUM eValue;
-          if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, FALSE) &&
+          if (pKeep->TryEnum(XFA_ATTRIBUTE_Previous, eValue, false) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
           CXFA_Node* pNode =
               pPreviewRow->GetFirstChildByClass(XFA_Element::Keep);
-          if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, FALSE) &&
+          if (pNode && pNode->TryEnum(XFA_ATTRIBUTE_Next, eValue, false) &&
               (eValue == XFA_ATTRIBUTEENUM_ContentArea ||
                eValue == XFA_ATTRIBUTEENUM_PageArea)) {
             return XFA_ATTRIBUTEENUM_ContentArea;
           }
         }
       }
       return eIntact;
     }
   }
   switch (GetElementType()) {
@@ skipping 20 matching lines @@
         XFA_ATTRIBUTEENUM eParLayout =
             pParentNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eParLayout == XFA_ATTRIBUTEENUM_Position ||
             eParLayout == XFA_ATTRIBUTEENUM_Row ||
             eParLayout == XFA_ATTRIBUTEENUM_Table) {
           return XFA_ATTRIBUTEENUM_None;
         }
         XFA_VERSION version = m_pDocument->GetCurVersionMode();
         if (eParLayout == XFA_ATTRIBUTEENUM_Tb && version < XFA_VERSION_208) {
           CXFA_Measurement measureH;
-          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, FALSE))
+          if (TryMeasure(XFA_ATTRIBUTE_H, measureH, false))
             return XFA_ATTRIBUTEENUM_ContentArea;
         }
         return XFA_ATTRIBUTEENUM_None;
       }
       return XFA_ATTRIBUTEENUM_ContentArea;
     }
     case XFA_Element::Draw:
       return XFA_ATTRIBUTEENUM_ContentArea;
     default:
       break;
@@ skipping 40 matching lines @@
     CXFA_Object* pNode = resoveNodeRS.nodes[0];
     pArguments->GetReturnValue()->Assign(
         pScriptContext->GetJSValueFromMap(pNode));
   } else {
     const XFA_SCRIPTATTRIBUTEINFO* lpAttributeInfo =
         resoveNodeRS.pScriptAttribute;
     if (lpAttributeInfo && lpAttributeInfo->eValueType == XFA_SCRIPT_Object) {
       std::unique_ptr<CFXJSE_Value> pValue(
           new CFXJSE_Value(pScriptContext->GetRuntime()));
       (resoveNodeRS.nodes[0]->*(lpAttributeInfo->lpfnCallback))(
-          pValue.get(), FALSE, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
+          pValue.get(), false, (XFA_ATTRIBUTE)lpAttributeInfo->eAttribute);
       pArguments->GetReturnValue()->Assign(pValue.get());
     } else {
       pArguments->GetReturnValue()->SetNull();
     }
   }
 }
 
 void CXFA_Node::Script_TreeClass_ResolveNodes(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
@@ skipping 40 matching lines @@
       for (int32_t i = 0; i < objectArray.GetSize(); i++) {
         if (objectArray[i]->IsNode())
           pNodeList->Append(objectArray[i]->AsNode());
       }
     }
   }
   pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass());
 }
 
 void CXFA_Node::Script_TreeClass_All(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideString wsName;
     GetAttribute(XFA_ATTRIBUTE_Name, wsName);
     CFX_WideString wsExpression = wsName + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
 
 void CXFA_Node::Script_TreeClass_Nodes(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
   if (!pScriptContext)
     return;
   if (bSetting) {
     IXFA_AppProvider* pAppProvider = m_pDocument->GetNotify()->GetAppProvider();
     ASSERT(pAppProvider);
     CFX_WideString wsMessage;
     pAppProvider->LoadString(XFA_IDS_Unable_TO_SET, wsMessage);
     FXJSE_ThrowMessage(
         FX_UTF8Encode(wsMessage.c_str(), wsMessage.GetLength()).AsStringC());
   } else {
     CXFA_AttachNodeList* pNodeList = new CXFA_AttachNodeList(m_pDocument, this);
     pValue->SetObject(pNodeList, pScriptContext->GetJseNormalClass());
   }
 }
 
 void CXFA_Node::Script_TreeClass_ClassAll(CFXJSE_Value* pValue,
-                                          FX_BOOL bSetting,
+                                          bool bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     uint32_t dwFlag = XFA_RESOLVENODE_Siblings | XFA_RESOLVENODE_ALL;
     CFX_WideString wsExpression =
         FX_WSTRC(L"#") + GetClassName() + FX_WSTRC(L"[*]");
     Script_Som_ResolveNodeList(pValue, wsExpression, dwFlag);
   }
 }
 
 void CXFA_Node::Script_TreeClass_Parent(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
     if (pParent) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pParent));
     } else {
       pValue->SetNull();
     }
   }
 }
 
 void CXFA_Node::Script_TreeClass_Index(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     pValue->SetInteger(GetNodeSameNameIndex());
 }
 
 void CXFA_Node::Script_TreeClass_ClassIndex(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     pValue->SetInteger(GetNodeSameClassIndex());
 }
 
 void CXFA_Node::Script_TreeClass_SomExpression(CFXJSE_Value* pValue,
-                                               FX_BOOL bSetting,
+                                               bool bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsSOMExpression;
     GetSOMExpression(wsSOMExpression);
     pValue->SetString(FX_UTF8Encode(wsSOMExpression).AsStringC());
   }
 }
 
@@ skipping 88 matching lines @@
   }
   CFX_WideString wsExpression;
   bool bParent = true;
   int32_t iIndex = 0;
   wsExpression =
       CFX_WideString::FromUTF8(pArguments->GetUTF8String(0).AsStringC());
   if (iLength >= 2)
     bParent = !!pArguments->GetInt32(1);
   if (iLength >= 3)
     iIndex = pArguments->GetInt32(2);
-  FX_BOOL bHas = FALSE;
+  bool bHas = false;
   const XFA_ATTRIBUTEINFO* pAttributeInfo =
       XFA_GetAttributeByName(wsExpression.AsStringC());
   CFX_WideString wsValue;
   if (pAttributeInfo)
     bHas = HasAttribute(pAttributeInfo->eName);
   if (!bHas) {
     XFA_Element eType = XFA_GetElementTypeForName(wsExpression.AsStringC());
     bHas = !!GetProperty(iIndex, eType);
     if (!bHas && bParent && m_pParent) {
       // Also check on the parent.
@@ skipping 31 matching lines @@
   CFDE_XMLNode* pXMLNode = nullptr;
   int32_t iParserStatus =
       pParser->ParseXMLData(wsExpression, pXMLNode, nullptr);
   if (iParserStatus != XFA_PARSESTATUS_Done || !pXMLNode)
     return;
   if (bIgnoreRoot &&
       (pXMLNode->GetType() != FDE_XMLNODE_Element ||
        XFA_RecognizeRichText(static_cast<CFDE_XMLElement*>(pXMLNode)))) {
     bIgnoreRoot = false;
   }
-  CXFA_Node* pFakeRoot = Clone(FALSE);
+  CXFA_Node* pFakeRoot = Clone(false);
   CFX_WideStringC wsContentType = GetCData(XFA_ATTRIBUTE_ContentType);
   if (!wsContentType.IsEmpty()) {
     pFakeRoot->SetCData(XFA_ATTRIBUTE_ContentType,
                         CFX_WideString(wsContentType));
   }
   CFDE_XMLNode* pFakeXMLRoot = pFakeRoot->GetXMLMappingNode();
   if (!pFakeXMLRoot) {
     CFDE_XMLNode* pThisXMLRoot = GetXMLMappingNode();
-    pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(FALSE) : nullptr;
+    pFakeXMLRoot = pThisXMLRoot ? pThisXMLRoot->Clone(false) : nullptr;
   }
   if (!pFakeXMLRoot)
     pFakeXMLRoot = new CFDE_XMLElement(CFX_WideString(GetClassName()));
 
   if (bIgnoreRoot) {
     CFDE_XMLNode* pXMLChild = pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
     while (pXMLChild) {
       CFDE_XMLNode* pXMLSibling =
           pXMLChild->GetNodeItem(CFDE_XMLNode::NextSibling);
       pXMLNode->RemoveChildNode(pXMLChild);
@@ skipping 31 matching lines @@
           GetElementType() == XFA_Element::ExData) {
         CFDE_XMLNode* pTempXMLNode = GetXMLMappingNode();
         SetXMLMappingNode(pFakeXMLRoot);
         SetFlag(XFA_NodeFlag_OwnXMLNode, false);
         if (pTempXMLNode && !pTempXMLNode->GetNodeItem(CFDE_XMLNode::Parent)) {
           pFakeXMLRoot = pTempXMLNode;
         } else {
           pFakeXMLRoot = nullptr;
         }
       }
-      MoveBufferMapData(pFakeRoot, this, XFA_CalcData, TRUE);
+      MoveBufferMapData(pFakeRoot, this, XFA_CalcData, true);
     } else {
       CXFA_Node* pChild = pFakeRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
       while (pChild) {
         CXFA_Node* pItem = pChild->GetNodeItem(XFA_NODEITEM_NextSibling);
         pFakeRoot->RemoveChild(pChild);
         InsertChild(pChild);
         pChild->SetFlag(XFA_NodeFlag_Initialized, true);
         pChild = pItem;
       }
     }
@@ skipping 34 matching lines @@
     CFDE_XMLNode* pElement = nullptr;
     if (GetPacketID() == XFA_XDPPACKET_Datasets) {
       pElement = GetXMLMappingNode();
       if (!pElement || pElement->GetType() != FDE_XMLNODE_Element) {
         pArguments->GetReturnValue()->SetString(bsXMLHeader);
         return;
       }
       XFA_DataExporter_DealWithDataGroupNode(this);
     }
     std::unique_ptr<IFX_MemoryStream, ReleaseDeleter<IFX_MemoryStream>>
-        pMemoryStream(FX_CreateMemoryStream(TRUE));
+        pMemoryStream(FX_CreateMemoryStream(true));
     std::unique_ptr<IFX_Stream, ReleaseDeleter<IFX_Stream>> pStream(
         IFX_Stream::CreateStream(
             static_cast<IFX_SeekableWriteStream*>(pMemoryStream.get()),
             FX_STREAMACCESS_Text | FX_STREAMACCESS_Write |
                 FX_STREAMACCESS_Append));
     if (!pStream) {
       pArguments->GetReturnValue()->SetString(bsXMLHeader);
       return;
     }
     pStream->SetCodePage(FX_CODEPAGE_UTF8);
     pStream->WriteData(bsXMLHeader.raw_str(), bsXMLHeader.GetLength());
     if (GetPacketID() == XFA_XDPPACKET_Form)
-      XFA_DataExporter_RegenerateFormFile(this, pStream.get(), nullptr, TRUE);
+      XFA_DataExporter_RegenerateFormFile(this, pStream.get(), nullptr, true);
     else
       pElement->SaveXMLNode(pStream.get());
     // TODO(weili): Check whether we need to save pretty print XML, pdfium:501.
     // For now, just put it here to avoid unused variable warning.
     (void)bPrettyMode;
     pArguments->GetReturnValue()->SetString(
         CFX_ByteStringC(pMemoryStream->GetBuffer(), pMemoryStream->GetSize()));
     return;
   }
   pArguments->GetReturnValue()->SetString("");
@@ skipping 23 matching lines @@
   pNode = static_cast<CXFA_Node*>(pArguments->GetObject(0));
   if (iLength == 2)
     wsName = CFX_WideString::FromUTF8(pArguments->GetUTF8String(1).AsStringC());
   // TODO(weili): check whether we need to implement this, pdfium:501.
   // For now, just put the variables here to avoid unused variable warning.
   (void)pNode;
   (void)wsName;
 }
 
 void CXFA_Node::Script_NodeClass_Ns(CFXJSE_Value* pValue,
-                                    FX_BOOL bSetting,
+                                    bool bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CFX_WideString wsNameSpace;
     TryNamespace(wsNameSpace);
     pValue->SetString(FX_UTF8Encode(wsNameSpace).AsStringC());
   }
 }
 
 void CXFA_Node::Script_NodeClass_Model(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     pValue->Assign(
         m_pDocument->GetScriptContext()->GetJSValueFromMap(GetModelNode()));
   }
 }
 
 void CXFA_Node::Script_NodeClass_IsContainer(CFXJSE_Value* pValue,
-                                             FX_BOOL bSetting,
+                                             bool bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting)
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   else
     pValue->SetBoolean(IsContainerNode());
 }
 
 void CXFA_Node::Script_NodeClass_IsNull(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     if (GetElementType() == XFA_Element::Subform) {
-      pValue->SetBoolean(FALSE);
+      pValue->SetBoolean(false);
       return;
     }
     CFX_WideString strValue;
     pValue->SetBoolean(!TryContent(strValue) || strValue.IsEmpty());
   }
 }
 
 void CXFA_Node::Script_NodeClass_OneOfChild(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_NodeArray properts;
     int32_t iSize = GetNodeList(properts, XFA_NODEFILTER_OneOfProperty);
     if (iSize > 0) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(properts[0]));
     }
@@ skipping 26 matching lines @@
     wsNameSpace = CFX_WideString::FromUTF8(bsNameSpace.AsStringC());
   }
   CFX_WideString wsNodeNameSpace;
   TryNamespace(wsNodeNameSpace);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(wsNodeNameSpace == wsNameSpace);
 }
 
 void CXFA_Node::Script_ModelClass_Context(CFXJSE_Value* pValue,
-                                          FX_BOOL bSetting,
+                                          bool bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_ModelClass_AliasNode(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Attribute_Integer(CFXJSE_Value* pValue,
-                                         FX_BOOL bSetting,
+                                         bool bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetInteger(eAttribute, pValue->ToInteger(), true);
   } else {
     pValue->SetInteger(GetInteger(eAttribute));
   }
 }
 
 void CXFA_Node::Script_Attribute_IntegerRead(CFXJSE_Value* pValue,
-                                             FX_BOOL bSetting,
+                                             bool bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     pValue->SetInteger(GetInteger(eAttribute));
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_Attribute_BOOL(CFXJSE_Value* pValue,
-                                      FX_BOOL bSetting,
+                                      bool bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetBoolean(eAttribute, pValue->ToBoolean(), true);
   } else {
     pValue->SetString(GetBoolean(eAttribute) ? "1" : "0");
   }
 }
 
 void CXFA_Node::Script_Attribute_BOOLRead(CFXJSE_Value* pValue,
-                                          FX_BOOL bSetting,
+                                          bool bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     pValue->SetString(GetBoolean(eAttribute) ? "1" : "0");
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_Attribute_SendAttributeChangeMessage(
     XFA_ATTRIBUTE eAttribute,
-    FX_BOOL bScriptModify) {
+    bool bScriptModify) {
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro)
     return;
 
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify)
     return;
 
   uint32_t dwPacket = GetPacketID();
   if (!(dwPacket & XFA_XDPPACKET_Form)) {
@@ skipping 131 matching lines @@
 
       pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
     }
     if (pParent) {
       pLayoutPro->AddChangedContainer(pParent);
     }
   }
 }
 
 void CXFA_Node::Script_Attribute_String(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_WideString wsValue = pValue->ToWideString();
     SetAttribute(eAttribute, wsValue.AsStringC(), true);
     if (eAttribute == XFA_ATTRIBUTE_Use &&
         GetElementType() == XFA_Element::Desc) {
       CXFA_Node* pTemplateNode =
           ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
       CXFA_Node* pProtoRoot =
           pTemplateNode->GetFirstChildByClass(XFA_Element::Subform)
@@ skipping 24 matching lines @@
         pProtoNode = m_pDocument->GetNodeByID(pProtoRoot, wsID.AsStringC());
       }
       if (pProtoNode) {
         CXFA_Node* pHeadChild = GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pHeadChild) {
           CXFA_Node* pSibling =
               pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
           RemoveChild(pHeadChild);
           pHeadChild = pSibling;
         }
-        CXFA_Node* pProtoForm = pProtoNode->CloneTemplateToForm(TRUE);
+        CXFA_Node* pProtoForm = pProtoNode->CloneTemplateToForm(true);
         pHeadChild = pProtoForm->GetNodeItem(XFA_NODEITEM_FirstChild);
         while (pHeadChild) {
           CXFA_Node* pSibling =
               pHeadChild->GetNodeItem(XFA_NODEITEM_NextSibling);
           pProtoForm->RemoveChild(pHeadChild);
           InsertChild(pHeadChild);
           pHeadChild = pSibling;
         }
         m_pDocument->RemovePurgeNode(pProtoForm);
         delete pProtoForm;
       }
     }
   } else {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     pValue->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Attribute_StringRead(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideString wsValue;
     GetAttribute(eAttribute, wsValue);
     pValue->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_WsdlConnection_Execute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc == 0) || (argc == 1)) {
-    pArguments->GetReturnValue()->SetBoolean(FALSE);
+    pArguments->GetReturnValue()->SetBoolean(false);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execute");
   }
 }
 
 void CXFA_Node::Script_Delta_Restore(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"restore");
   }
 }
 
 void CXFA_Node::Script_Delta_CurrentValue(CFXJSE_Value* pValue,
-                                          FX_BOOL bSetting,
+                                          bool bSetting,
                                           XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Delta_SavedValue(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Delta_Target(CFXJSE_Value* pValue,
-                                    FX_BOOL bSetting,
+                                    bool bSetting,
                                     XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Som_Message(CFXJSE_Value* pValue,
-                                   FX_BOOL bSetting,
+                                   bool bSetting,
                                    XFA_SOM_MESSAGETYPE iMessageType) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  FX_BOOL bNew = FALSE;
+  bool bNew = false;
   CXFA_Validate validate = pWidgetData->GetValidate();
   if (!validate) {
-    validate = pWidgetData->GetValidate(TRUE);
-    bNew = TRUE;
+    validate = pWidgetData->GetValidate(true);
+    bNew = true;
   }
   if (bSetting) {
     switch (iMessageType) {
       case XFA_SOM_ValidationMessage:
         validate.SetScriptMessageText(pValue->ToWideString());
         break;
       case XFA_SOM_FormatMessage:
         validate.SetFormatMessageText(pValue->ToWideString());
         break;
       case XFA_SOM_MandatoryMessage:
@@ skipping 22 matching lines @@
         validate.GetNullMessageText(wsMessage);
         break;
       default:
         break;
     }
     pValue->SetString(FX_UTF8Encode(wsMessage).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_ValidationMessage(CFXJSE_Value* pValue,
-                                             FX_BOOL bSetting,
+                                             bool bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_ValidationMessage);
 }
 
 void CXFA_Node::Script_Field_Length(CFXJSE_Value* pValue,
-                                    FX_BOOL bSetting,
+                                    bool bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
       pValue->SetInteger(0);
       return;
     }
-    pValue->SetInteger(pWidgetData->CountChoiceListItems(TRUE));
+    pValue->SetInteger(pWidgetData->CountChoiceListItems(true));
   }
 }
 
 void CXFA_Node::Script_Som_DefaultValue(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   XFA_Element eType = GetElementType();
   if (eType == XFA_Element::Field) {
     Script_Field_DefaultValue(pValue, bSetting, eAttribute);
     return;
   }
   if (eType == XFA_Element::Draw) {
     Script_Draw_DefaultValue(pValue, bSetting, eAttribute);
     return;
   }
@@ skipping 26 matching lines @@
           break;
         }
         pContainerWidgetData = nullptr;
       }
     } else if (GetPacketID() == XFA_XDPPACKET_Form) {
       pContainerWidgetData = GetContainerWidgetData();
     }
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
-    SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
+    SetScriptContent(wsNewValue, wsFormatValue, true, true);
   } else {
-    CFX_WideString content = GetScriptContent(TRUE);
+    CFX_WideString content = GetScriptContent(true);
     if (content.IsEmpty() && eType != XFA_Element::Text &&
         eType != XFA_Element::SubmitUrl) {
       pValue->SetNull();
     } else if (eType == XFA_Element::Integer) {
       pValue->SetInteger(FXSYS_wtoi(content.c_str()));
     } else if (eType == XFA_Element::Float || eType == XFA_Element::Decimal) {
       CFX_Decimal decimal(content.AsStringC());
       pValue->SetFloat((FX_FLOAT)(double)decimal);
     } else {
       pValue->SetString(
           FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
     }
   }
 }
 
 void CXFA_Node::Script_Som_DefaultValue_Read(CFXJSE_Value* pValue,
-                                             FX_BOOL bSetting,
+                                             bool bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
-  CFX_WideString content = GetScriptContent(TRUE);
+  CFX_WideString content = GetScriptContent(true);
   if (content.IsEmpty()) {
     pValue->SetNull();
   } else {
     pValue->SetString(
         FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Boolean_Value(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFX_ByteString newValue;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       newValue = pValue->ToString();
 
     int32_t iValue = FXSYS_atoi(newValue.c_str());
     CFX_WideString wsNewValue(iValue == 0 ? L"0" : L"1");
     CFX_WideString wsFormatValue(wsNewValue);
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewValue, wsFormatValue);
     }
-    SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
+    SetScriptContent(wsNewValue, wsFormatValue, true, true);
   } else {
-    CFX_WideString wsValue = GetScriptContent(TRUE);
+    CFX_WideString wsValue = GetScriptContent(true);
     pValue->SetBoolean(wsValue == FX_WSTRC(L"1"));
   }
 }
 
 void CXFA_Node::Script_Som_BorderColor(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
+  CXFA_Border border = pWidgetData->GetBorder(true);
   int32_t iSize = border.CountEdges();
   if (bSetting) {
     int32_t r = 0;
     int32_t g = 0;
     int32_t b = 0;
     StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB rgb = ArgbEncode(100, r, g, b);
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
       edge.SetColor(rgb);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     FX_ARGB color = edge.GetColor();
     int32_t a, r, g, b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString strColor;
     strColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(strColor).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_BorderWidth(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
+  CXFA_Border border = pWidgetData->GetBorder(true);
   int32_t iSize = border.CountEdges();
   CFX_WideString wsThickness;
   if (bSetting) {
     wsThickness = pValue->ToWideString();
     for (int32_t i = 0; i < iSize; ++i) {
       CXFA_Edge edge = border.GetEdge(i);
       CXFA_Measurement thickness(wsThickness.AsStringC());
       edge.SetMSThickness(thickness);
     }
   } else {
     CXFA_Edge edge = border.GetEdge(0);
     CXFA_Measurement thickness = edge.GetMSThickness();
     thickness.ToString(wsThickness);
     pValue->SetString(FX_UTF8Encode(wsThickness).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_FillColor(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  CXFA_Border border = pWidgetData->GetBorder(TRUE);
-  CXFA_Fill borderfill = border.GetFill(TRUE);
+  CXFA_Border border = pWidgetData->GetBorder(true);
+  CXFA_Fill borderfill = border.GetFill(true);
   CXFA_Node* pNode = borderfill.GetNode();
   if (!pNode) {
     return;
   }
   if (bSetting) {
     int32_t r;
     int32_t g;
     int32_t b;
     StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     borderfill.SetColor(color);
   } else {
     FX_ARGB color = borderfill.GetColor();
     int32_t a;
     int32_t r;
     int32_t g;
     int32_t b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString wsColor;
     wsColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(wsColor).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_DataNode(CFXJSE_Value* pValue,
-                                    FX_BOOL bSetting,
+                                    bool bSetting,
                                     XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CXFA_Node* pDataNode = GetBindData();
     if (pDataNode) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pDataNode));
     } else {
       pValue->SetNull();
     }
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_Draw_DefaultValue(CFXJSE_Value* pValue,
-                                         FX_BOOL bSetting,
+                                         bool bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     if (pValue && pValue->IsString()) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       ASSERT(pWidgetData);
       XFA_Element uiType = pWidgetData->GetUIType();
       if (uiType == XFA_Element::Text) {
         CFX_WideString wsNewValue = pValue->ToWideString();
         CFX_WideString wsFormatValue(wsNewValue);
-        SetScriptContent(wsNewValue, wsFormatValue, true, TRUE);
+        SetScriptContent(wsNewValue, wsFormatValue, true, true);
       }
     }
   } else {
-    CFX_WideString content = GetScriptContent(TRUE);
+    CFX_WideString content = GetScriptContent(true);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
       pValue->SetString(
           FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
     }
   }
 }
 
 void CXFA_Node::Script_Field_DefaultValue(CFXJSE_Value* pValue,
-                                          FX_BOOL bSetting,
+                                          bool bSetting,
                                           XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     if (pValue && pValue->IsNull()) {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
-      pWidgetData->m_bIsNull = TRUE;
+      pWidgetData->m_bIsNull = true;
     } else {
       pWidgetData->m_bPreNull = pWidgetData->m_bIsNull;
-      pWidgetData->m_bIsNull = FALSE;
+      pWidgetData->m_bIsNull = false;
     }
     CFX_WideString wsNewText;
     if (!(pValue && (pValue->IsNull() || pValue->IsUndefined())))
       wsNewText = pValue->ToWideString();
 
     CXFA_Node* pUIChild = pWidgetData->GetUIChild();
     if (pUIChild->GetElementType() == XFA_Element::NumericEdit) {
       int32_t iLeadDigits = 0;
       int32_t iFracDigits = 0;
       pWidgetData->GetLeadDigits(iLeadDigits);
       pWidgetData->GetFracDigits(iFracDigits);
       wsNewText =
           pWidgetData->NumericLimit(wsNewText, iLeadDigits, iFracDigits);
     }
     CXFA_WidgetData* pContainerWidgetData = GetContainerWidgetData();
     CFX_WideString wsFormatText(wsNewText);
     if (pContainerWidgetData) {
       pContainerWidgetData->GetFormatDataValue(wsNewText, wsFormatText);
     }
-    SetScriptContent(wsNewText, wsFormatText, true, TRUE);
+    SetScriptContent(wsNewText, wsFormatText, true, true);
   } else {
-    CFX_WideString content = GetScriptContent(TRUE);
+    CFX_WideString content = GetScriptContent(true);
     if (content.IsEmpty()) {
       pValue->SetNull();
     } else {
       CXFA_Node* pUIChild = pWidgetData->GetUIChild();
       CXFA_Value defVal = pWidgetData->GetFormValue();
       CXFA_Node* pNode = defVal.GetNode()->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (pNode && pNode->GetElementType() == XFA_Element::Decimal) {
         if (pUIChild->GetElementType() == XFA_Element::NumericEdit &&
             (pNode->GetInteger(XFA_ATTRIBUTE_FracDigits) == -1)) {
           pValue->SetString(
               FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
         } else {
           CFX_Decimal decimal(content.AsStringC());
           pValue->SetFloat((FX_FLOAT)(double)decimal);
         }
       } else if (pNode && pNode->GetElementType() == XFA_Element::Integer) {
         pValue->SetInteger(FXSYS_wtoi(content.c_str()));
       } else if (pNode && pNode->GetElementType() == XFA_Element::Boolean) {
-        pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? FALSE : TRUE);
+        pValue->SetBoolean(FXSYS_wtoi(content.c_str()) == 0 ? false : true);
       } else if (pNode && pNode->GetElementType() == XFA_Element::Float) {
         CFX_Decimal decimal(content.AsStringC());
         pValue->SetFloat((FX_FLOAT)(double)decimal);
       } else {
         pValue->SetString(
             FX_UTF8Encode(content.c_str(), content.GetLength()).AsStringC());
       }
     }
   }
 }
 
 void CXFA_Node::Script_Field_EditValue(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Edit);
   } else {
     CFX_WideString wsValue;
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Edit);
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_FontColor(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  CXFA_Font font = pWidgetData->GetFont(TRUE);
+  CXFA_Font font = pWidgetData->GetFont(true);
   CXFA_Node* pNode = font.GetNode();
   if (!pNode) {
     return;
   }
   if (bSetting) {
     int32_t r;
     int32_t g;
     int32_t b;
     StrToRGB(pValue->ToWideString(), r, g, b);
     FX_ARGB color = ArgbEncode(0xff, r, g, b);
     font.SetColor(color);
   } else {
     FX_ARGB color = font.GetColor();
     int32_t a;
     int32_t r;
     int32_t g;
     int32_t b;
     ArgbDecode(color, a, r, g, b);
     CFX_WideString wsColor;
     wsColor.Format(L"%d,%d,%d", r, g, b);
     pValue->SetString(FX_UTF8Encode(wsColor).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Field_FormatMessage(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_FormatMessage);
 }
 
 void CXFA_Node::Script_Field_FormattedValue(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetValue(pValue->ToWideString(), XFA_VALUEPICTURE_Display);
   } else {
     CFX_WideString wsValue;
     pWidgetData->GetValue(wsValue, XFA_VALUEPICTURE_Display);
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_Mandatory(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  CXFA_Validate validate = pWidgetData->GetValidate(TRUE);
+  CXFA_Validate validate = pWidgetData->GetValidate(true);
   if (bSetting) {
     validate.SetNullTest(pValue->ToWideString());
   } else {
     int32_t iValue = validate.GetNullTest();
     const XFA_ATTRIBUTEENUMINFO* pInfo =
         GetAttributeEnumByID((XFA_ATTRIBUTEENUM)iValue);
     CFX_WideString wsValue;
     if (pInfo)
       wsValue = pInfo->pName;
     pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Som_MandatoryMessage(CFXJSE_Value* pValue,
-                                            FX_BOOL bSetting,
+                                            bool bSetting,
                                             XFA_ATTRIBUTE eAttribute) {
   Script_Som_Message(pValue, bSetting, XFA_SOM_MandatoryMessage);
 }
 
 void CXFA_Node::Script_Field_ParentSubform(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   } else {
     pValue->SetNull();
   }
 }
 
 void CXFA_Node::Script_Field_SelectedIndex(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     int32_t iIndex = pValue->ToInteger();
     if (iIndex == -1) {
       pWidgetData->ClearAllSelections();
       return;
     }
-    pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE);
+    pWidgetData->SetItemState(iIndex, true, true, true, true);
   } else {
     pValue->SetInteger(pWidgetData->GetSelectedItem());
   }
 }
 
 void CXFA_Node::Script_Field_ClearItems(CFXJSE_Arguments* pArguments) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
-  pWidgetData->DeleteItem(-1, TRUE);
+  pWidgetData->DeleteItem(-1, true);
 }
 
 void CXFA_Node::Script_Field_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     int32_t iRet = execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::Field);
     if (eventString == "validate") {
       pArguments->GetReturnValue()->SetBoolean(
-          (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
+          (iRet == XFA_EVENTERROR_Error) ? false : true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execEvent");
   }
 }
 
 void CXFA_Node::Script_Field_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, FALSE, FALSE);
+    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Initialize, false, false);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 
 void CXFA_Node::Script_Field_DeleteItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"deleteItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bValue = pWidgetData->DeleteItem(iIndex, TRUE, TRUE);
+  bool bValue = pWidgetData->DeleteItem(iIndex, true, true);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(bValue);
 }
 
 void CXFA_Node::Script_Field_GetSaveItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getSaveItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CFX_WideString wsValue;
-  FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, TRUE);
+  bool bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, true);
   if (bHasItem) {
     pArguments->GetReturnValue()->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     pArguments->GetReturnValue()->SetNull();
   }
 }
 
 void CXFA_Node::Script_Field_BoundItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
@@ skipping 18 matching lines @@
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getItemState");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bValue = pWidgetData->GetItemState(iIndex);
+  bool bValue = pWidgetData->GetItemState(iIndex);
   CFXJSE_Value* pValue = pArguments->GetReturnValue();
   if (pValue)
     pValue->SetBoolean(bValue);
 }
 
 void CXFA_Node::Script_Field_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
-    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, FALSE, FALSE);
+    pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate, false, false);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 
 void CXFA_Node::Script_Field_SetItems(CFXJSE_Arguments* pArguments) {}
 
 void CXFA_Node::Script_Field_GetDisplayItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 1) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"getDisplayItem");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
   if (iIndex < 0) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     pArguments->GetReturnValue()->SetNull();
     return;
   }
   CFX_WideString wsValue;
-  FX_BOOL bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, FALSE);
+  bool bHasItem = pWidgetData->GetChoiceListItem(wsValue, iIndex, false);
   if (bHasItem) {
     pArguments->GetReturnValue()->SetString(
         FX_UTF8Encode(wsValue.c_str(), wsValue.GetLength()).AsStringC());
   } else {
     pArguments->GetReturnValue()->SetNull();
   }
 }
 
 void CXFA_Node::Script_Field_SetItemState(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength != 2) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"setItemState");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData)
     return;
 
   int32_t iIndex = pArguments->GetInt32(0);
   if (pArguments->GetInt32(1) != 0) {
-    pWidgetData->SetItemState(iIndex, TRUE, true, TRUE, TRUE);
+    pWidgetData->SetItemState(iIndex, true, true, true, true);
   } else {
     if (pWidgetData->GetItemState(iIndex))
-      pWidgetData->SetItemState(iIndex, FALSE, true, TRUE, TRUE);
+      pWidgetData->SetItemState(iIndex, false, true, true, true);
   }
 }
 
 void CXFA_Node::Script_Field_AddItem(CFXJSE_Arguments* pArguments) {
   int32_t iLength = pArguments->GetLength();
   if (iLength < 1 || iLength > 2) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addItem");
     return;
   }
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   CFX_WideString wsLabel;
   CFX_WideString wsValue;
   if (iLength >= 1) {
     CFX_ByteString bsLabel = pArguments->GetUTF8String(0);
     wsLabel = CFX_WideString::FromUTF8(bsLabel.AsStringC());
   }
   if (iLength >= 2) {
     CFX_ByteString bsValue = pArguments->GetUTF8String(1);
     wsValue = CFX_WideString::FromUTF8(bsValue.AsStringC());
   }
-  pWidgetData->InsertItem(wsLabel, wsValue, -1, TRUE);
+  pWidgetData->InsertItem(wsLabel, wsValue, -1, true);
 }
 
 void CXFA_Node::Script_Field_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
       int32_t iRet =
-          pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, FALSE, FALSE);
+          pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate, false, false);
       pArguments->GetReturnValue()->SetBoolean(
-          (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
+          (iRet == XFA_EVENTERROR_Error) ? false : true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 
 void CXFA_Node::Script_ExclGroup_ErrorText(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_ExclGroup_DefaultAndRawValue(CFXJSE_Value* pValue,
-                                                    FX_BOOL bSetting,
+                                                    bool bSetting,
                                                     XFA_ATTRIBUTE eAttribute) {
   CXFA_WidgetData* pWidgetData = GetWidgetData();
   if (!pWidgetData) {
     return;
   }
   if (bSetting) {
     pWidgetData->SetSelectedMemberByValue(pValue->ToWideString().AsStringC(),
-                                          true, TRUE, TRUE);
+                                          true, true, true);
   } else {
-    CFX_WideString wsValue = GetScriptContent(TRUE);
+    CFX_WideString wsValue = GetScriptContent(true);
     XFA_VERSION curVersion = GetDocument()->GetCurVersionMode();
     if (wsValue.IsEmpty() && curVersion >= XFA_VERSION_300) {
       pValue->SetNull();
     } else {
       pValue->SetString(FX_UTF8Encode(wsValue).AsStringC());
     }
   }
 }
 
 void CXFA_Node::Script_ExclGroup_Transient(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_ExclGroup_ExecEvent(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString eventString = pArguments->GetUTF8String(0);
     execSingleEventByName(
         CFX_WideString::FromUTF8(eventString.AsStringC()).AsStringC(),
         XFA_Element::ExclGroup);
   } else {
@@ skipping 55 matching lines @@
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 
 void CXFA_Node::Script_ExclGroup_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
-          (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
+          (iRet == XFA_EVENTERROR_Error) ? false : true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 
 void CXFA_Node::Script_Som_InstanceIndex(CFXJSE_Value* pValue,
-                                         FX_BOOL bSetting,
+                                         bool bSetting,
                                          XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iTo = pValue->ToInteger();
     int32_t iFrom = Subform_and_SubformSet_InstanceIndex();
     CXFA_Node* pManagerNode = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         pManagerNode = pNode;
         break;
@@ skipping 15 matching lines @@
           pFromInstance->GetElementType() == XFA_Element::Subform) {
         pNotify->RunSubformIndexChange(pFromInstance);
       }
     }
   } else {
     pValue->SetInteger(Subform_and_SubformSet_InstanceIndex());
   }
 }
 
 void CXFA_Node::Script_Subform_InstanceManager(CFXJSE_Value* pValue,
-                                               FX_BOOL bSetting,
+                                               bool bSetting,
                                                XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CFX_WideStringC wsName = GetCData(XFA_ATTRIBUTE_Name);
     CXFA_Node* pInstanceMgr = nullptr;
     for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_PrevSibling); pNode;
          pNode = pNode->GetNodeItem(XFA_NODEITEM_PrevSibling)) {
       if (pNode->GetElementType() == XFA_Element::InstanceManager) {
         CFX_WideStringC wsInstMgrName = pNode->GetCData(XFA_ATTRIBUTE_Name);
         if (wsInstMgrName.GetLength() >= 1 && wsInstMgrName.GetAt(0) == '_' &&
             wsInstMgrName.Mid(1) == wsName) {
           pInstanceMgr = pNode;
         }
         break;
       }
     }
     if (pInstanceMgr) {
       pValue->Assign(
           m_pDocument->GetScriptContext()->GetJSValueFromMap(pInstanceMgr));
     } else {
       pValue->SetNull();
     }
   } else {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
   }
 }
 
 void CXFA_Node::Script_Subform_Locale(CFXJSE_Value* pValue,
-                                      FX_BOOL bSetting,
+                                      bool bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
-    SetCData(XFA_ATTRIBUTE_Locale, pValue->ToWideString(), true, TRUE);
+    SetCData(XFA_ATTRIBUTE_Locale, pValue->ToWideString(), true, true);
   } else {
     CFX_WideString wsLocaleName;
     GetLocaleName(wsLocaleName);
     pValue->SetString(
         FX_UTF8Encode(wsLocaleName.c_str(), wsLocaleName.GetLength())
             .AsStringC());
   }
 }
 
 void CXFA_Node::Script_Subform_ExecEvent(CFXJSE_Arguments* pArguments) {
@@ skipping 32 matching lines @@
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 
 void CXFA_Node::Script_Subform_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
-          (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
+          (iRet == XFA_EVENTERROR_Error) ? false : true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 
 void CXFA_Node::Script_Subform_GetInvalidObjects(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
@@ skipping 11 matching lines @@
     } else {
       break;
     }
   }
   return index;
 }
 
 void CXFA_Node::Script_Template_FormNodes(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
-    pArguments->GetReturnValue()->SetBoolean(TRUE);
+    pArguments->GetReturnValue()->SetBoolean(true);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
   }
 }
 
 void CXFA_Node::Script_Template_Remerge(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    m_pDocument->DoDataRemerge(TRUE);
+    m_pDocument->DoDataRemerge(true);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
   }
 }
 
 void CXFA_Node::Script_Template_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
-      pArguments->GetReturnValue()->SetBoolean(TRUE);
+      pArguments->GetReturnValue()->SetBoolean(true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execInitialize");
   }
 }
 
 void CXFA_Node::Script_Template_CreateNode(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc > 0) && (argc < 4)) {
     CFX_WideString strTagName;
@@ skipping 32 matching lines @@
             m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewNode));
       }
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"createNode");
   }
 }
 
 void CXFA_Node::Script_Template_Recalculate(CFXJSE_Arguments* pArguments) {
   if (pArguments->GetLength() == 1) {
-    pArguments->GetReturnValue()->SetBoolean(TRUE);
+    pArguments->GetReturnValue()->SetBoolean(true);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
   }
 }
 
 void CXFA_Node::Script_Template_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
-      pArguments->GetReturnValue()->SetBoolean(TRUE);
+      pArguments->GetReturnValue()->SetBoolean(true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 
 void CXFA_Node::Script_Template_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
-      pArguments->GetReturnValue()->SetBoolean(TRUE);
+      pArguments->GetReturnValue()->SetBoolean(true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 
 void CXFA_Node::Script_Manifest_Evaluate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_WidgetData* pWidgetData = GetWidgetData();
     if (!pWidgetData) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
-      pArguments->GetReturnValue()->SetBoolean(TRUE);
+      pArguments->GetReturnValue()->SetBoolean(true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"evaluate");
   }
 }
 
 void CXFA_Node::Script_InstanceManager_Max(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMax());
 }
 
 void CXFA_Node::Script_InstanceManager_Min(CFXJSE_Value* pValue,
-                                           FX_BOOL bSetting,
+                                           bool bSetting,
                                            XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   pValue->SetInteger(nodeOccur.GetMin());
 }
 
 void CXFA_Node::Script_InstanceManager_Count(CFXJSE_Value* pValue,
-                                             FX_BOOL bSetting,
+                                             bool bSetting,
                                              XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     int32_t iDesired = pValue->ToInteger();
     InstanceManager_SetInstances(iDesired);
   } else {
     pValue->SetInteger(GetCount(this));
   }
 }
 
 void CXFA_Node::Script_InstanceManager_MoveInstance(
@@ skipping 71 matching lines @@
   InstanceManager_SetInstances(iDesired);
 }
 
 void CXFA_Node::Script_InstanceManager_AddInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc != 0) && (argc != 1)) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"addInstance");
     return;
   }
-  FX_BOOL fFlags = TRUE;
+  bool fFlags = true;
   if (argc == 1) {
-    fFlags = pArguments->GetInt32(0) == 0 ? FALSE : TRUE;
+    fFlags = pArguments->GetInt32(0) == 0 ? false : true;
   }
   int32_t iCount = GetCount(this);
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance = CreateInstance(this, fFlags);
-  InsertItem(this, pNewInstance, iCount, iCount, FALSE);
+  InsertItem(this, pNewInstance, iCount, iCount, false);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
   }
   pLayoutPro->AddChangedContainer(
       ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
 }
 
 void CXFA_Node::Script_InstanceManager_InsertInstance(
     CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if ((argc != 1) && (argc != 2)) {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"insertInstance");
     return;
   }
   int32_t iIndex = pArguments->GetInt32(0);
-  FX_BOOL bBind = FALSE;
+  bool bBind = false;
   if (argc == 2) {
-    bBind = pArguments->GetInt32(1) == 0 ? FALSE : TRUE;
+    bBind = pArguments->GetInt32(1) == 0 ? false : true;
   }
   CXFA_Occur nodeOccur(GetOccurNode());
   int32_t iCount = GetCount(this);
   if (iIndex < 0 || iIndex > iCount) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return;
   }
   int32_t iMax = nodeOccur.GetMax();
   if (iMax >= 0 && iCount >= iMax) {
     ThrowException(XFA_IDS_VIOLATE_BOUNDARY, L"max");
     return;
   }
   CXFA_Node* pNewInstance = CreateInstance(this, bBind);
-  InsertItem(this, pNewInstance, iIndex, iCount, TRUE);
+  InsertItem(this, pNewInstance, iIndex, iCount, true);
   pArguments->GetReturnValue()->Assign(
       m_pDocument->GetScriptContext()->GetJSValueFromMap(pNewInstance));
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (!pNotify) {
     return;
   }
   pNotify->RunNodeInitialize(pNewInstance);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (!pLayoutPro) {
     return;
@@ skipping 28 matching lines @@
     CXFA_Node* pPrevSibling =
         (iDesired == 0) ? this : GetItem(this, iDesired - 1);
     while (iCount > iDesired) {
       CXFA_Node* pRemoveInstance =
           pPrevSibling->GetNodeItem(XFA_NODEITEM_NextSibling);
       if (pRemoveInstance->GetElementType() != XFA_Element::Subform &&
           pRemoveInstance->GetElementType() != XFA_Element::SubformSet) {
         continue;
       }
       if (pRemoveInstance->GetElementType() == XFA_Element::InstanceManager) {
-        ASSERT(FALSE);
+        ASSERT(false);
         break;
       }
       if (pRemoveInstance->GetNameHash() == dInstanceNameHash) {
         RemoveItem(this, pRemoveInstance);
         iCount--;
       }
     }
   } else if (iDesired > iCount) {
     while (iCount < iDesired) {
-      CXFA_Node* pNewInstance = CreateInstance(this, TRUE);
-      InsertItem(this, pNewInstance, iCount, iCount, FALSE);
+      CXFA_Node* pNewInstance = CreateInstance(this, true);
+      InsertItem(this, pNewInstance, iCount, iCount, false);
       iCount++;
       CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
       if (!pNotify) {
         return 0;
       }
       pNotify->RunNodeInitialize(pNewInstance);
     }
   }
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (pLayoutPro) {
     pLayoutPro->AddChangedContainer(
         ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
   return 0;
 }
 
 int32_t CXFA_Node::InstanceManager_MoveInstance(int32_t iTo, int32_t iFrom) {
   int32_t iCount = GetCount(this);
   if (iFrom > iCount || iTo > iCount - 1) {
     ThrowException(XFA_IDS_INDEX_OUT_OF_BOUNDS);
     return 1;
   }
   if (iFrom < 0 || iTo < 0 || iFrom == iTo) {
     return 0;
   }
   CXFA_Node* pMoveInstance = GetItem(this, iFrom);
-  RemoveItem(this, pMoveInstance, FALSE);
-  InsertItem(this, pMoveInstance, iTo, iCount - 1, TRUE);
+  RemoveItem(this, pMoveInstance, false);
+  InsertItem(this, pMoveInstance, iTo, iCount - 1, true);
   CXFA_LayoutProcessor* pLayoutPro = m_pDocument->GetLayoutProcessor();
   if (pLayoutPro) {
     pLayoutPro->AddChangedContainer(
         ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form)));
   }
   return 0;
 }
 
 void CXFA_Node::Script_Occur_Max(CFXJSE_Value* pValue,
-                                 FX_BOOL bSetting,
+                                 bool bSetting,
                                  XFA_ATTRIBUTE eAttribute) {
   CXFA_Occur occur(this);
   if (bSetting) {
     int32_t iMax = pValue->ToInteger();
     occur.SetMax(iMax);
   } else {
     pValue->SetInteger(occur.GetMax());
   }
 }
 
 void CXFA_Node::Script_Occur_Min(CFXJSE_Value* pValue,
-                                 FX_BOOL bSetting,
+                                 bool bSetting,
                                  XFA_ATTRIBUTE eAttribute) {
   CXFA_Occur occur(this);
   if (bSetting) {
     int32_t iMin = pValue->ToInteger();
     occur.SetMin(iMin);
   } else {
     pValue->SetInteger(occur.GetMin());
   }
 }
 
@@ skipping 20 matching lines @@
       ThrowException(XFA_IDS_ARGUMENT_MISMATCH);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"formNodes");
   }
 }
 
 void CXFA_Node::Script_Form_Remerge(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
-    m_pDocument->DoDataRemerge(TRUE);
+    m_pDocument->DoDataRemerge(true);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"remerge");
   }
 }
 
 void CXFA_Node::Script_Form_ExecInitialize(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
@@ skipping 15 matching lines @@
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     const bool bScriptFlags = pArguments->GetInt32(0) != 0;
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     if (bScriptFlags) {
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
       pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
-      pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, TRUE);
+      pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Ready, true);
     } else {
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"recalculate");
   }
 }
 
 void CXFA_Node::Script_Form_ExecCalculate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return;
     }
     pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Calculate);
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execCalculate");
   }
 }
 
 void CXFA_Node::Script_Form_ExecValidate(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
-      pArguments->GetReturnValue()->SetBoolean(FALSE);
+      pArguments->GetReturnValue()->SetBoolean(false);
     } else {
       int32_t iRet = pNotify->ExecEventByDeepFirst(this, XFA_EVENT_Validate);
       pArguments->GetReturnValue()->SetBoolean(
-          (iRet == XFA_EVENTERROR_Error) ? FALSE : TRUE);
+          (iRet == XFA_EVENTERROR_Error) ? false : true);
     }
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"execValidate");
   }
 }
 
 void CXFA_Node::Script_Form_Checksum(CFXJSE_Value* pValue,
-                                     FX_BOOL bSetting,
+                                     bool bSetting,
                                      XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     SetAttribute(XFA_ATTRIBUTE_Checksum, pValue->ToWideString().AsStringC());
   } else {
     CFX_WideString wsChecksum;
-    GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, FALSE);
+    GetAttribute(XFA_ATTRIBUTE_Checksum, wsChecksum, false);
     pValue->SetString(
         FX_UTF8Encode(wsChecksum.c_str(), wsChecksum.GetLength()).AsStringC());
   }
 }
 
 void CXFA_Node::Script_Packet_GetAttribute(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 1) {
     CFX_ByteString bsAttributeName = pArguments->GetUTF8String(0);
     CFX_WideString wsAttributeValue;
@@ skipping 40 matching lines @@
         pXMLElement->RemoveAttribute(wsName.c_str());
       }
     }
     pArguments->GetReturnValue()->SetNull();
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"removeAttribute");
   }
 }
 
 void CXFA_Node::Script_Packet_Content(CFXJSE_Value* pValue,
-                                      FX_BOOL bSetting,
+                                      bool bSetting,
                                       XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (pXMLNode && pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->SetTextData(pValue->ToWideString());
     }
   } else {
     CFX_WideString wsTextData;
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
@@ skipping 136 matching lines @@
 
 void CXFA_Node::Script_Source_HasDataChanged(CFXJSE_Arguments* pArguments) {
   int32_t argc = pArguments->GetLength();
   if (argc == 0) {
   } else {
     ThrowException(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"hasDataChanged");
   }
 }
 
 void CXFA_Node::Script_Source_Db(CFXJSE_Value* pValue,
-                                 FX_BOOL bSetting,
+                                 bool bSetting,
                                  XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Xfa_This(CFXJSE_Value* pValue,
-                                FX_BOOL bSetting,
+                                bool bSetting,
                                 XFA_ATTRIBUTE eAttribute) {
   if (!bSetting) {
     CXFA_Object* pThis = m_pDocument->GetScriptContext()->GetThisObject();
     ASSERT(pThis);
     pValue->Assign(m_pDocument->GetScriptContext()->GetJSValueFromMap(pThis));
   }
 }
 
 void CXFA_Node::Script_Handler_Version(CFXJSE_Value* pValue,
-                                       FX_BOOL bSetting,
+                                       bool bSetting,
                                        XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_SubmitFormat_Mode(CFXJSE_Value* pValue,
-                                         FX_BOOL bSetting,
+                                         bool bSetting,
                                          XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Extras_Type(CFXJSE_Value* pValue,
-                                   FX_BOOL bSetting,
+                                   bool bSetting,
                                    XFA_ATTRIBUTE eAttribute) {}
 
 void CXFA_Node::Script_Script_Stateless(CFXJSE_Value* pValue,
-                                        FX_BOOL bSetting,
+                                        bool bSetting,
                                         XFA_ATTRIBUTE eAttribute) {
   if (bSetting) {
     ThrowException(XFA_IDS_INVAlID_PROP_SET);
     return;
   }
   pValue->SetString(FX_UTF8Encode(FX_WSTRC(L"0")).AsStringC());
 }
 
 void CXFA_Node::Script_Encrypt_Format(CFXJSE_Value* pValue,
-                                      FX_BOOL bSetting,
+                                      bool bSetting,
                                       XFA_ATTRIBUTE eAttribute) {}
 
-FX_BOOL CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, FX_BOOL bCanInherit) {
+bool CXFA_Node::HasAttribute(XFA_ATTRIBUTE eAttr, bool bCanInherit) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   return HasMapModuleKey(pKey, bCanInherit);
 }
 
-FX_BOOL CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
-                                const CFX_WideStringC& wsValue,
-                                bool bNotify) {
+bool CXFA_Node::SetAttribute(XFA_ATTRIBUTE eAttr,
+                             const CFX_WideStringC& wsValue,
+                             bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr)
-    return FALSE;
+    return false;
 
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetElementType(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       const XFA_ATTRIBUTEENUMINFO* pEnum = XFA_GetAttributeEnumByName(wsValue);
       return SetEnum(pAttr->eName,
                      pEnum ? pEnum->eName
                            : (XFA_ATTRIBUTEENUM)(intptr_t)(pAttr->pDefValue),
                      bNotify);
     } break;
     case XFA_ATTRIBUTETYPE_Cdata:
       return SetCData(pAttr->eName, CFX_WideString(wsValue), bNotify);
     case XFA_ATTRIBUTETYPE_Boolean:
       return SetBoolean(pAttr->eName, wsValue != FX_WSTRC(L"0"), bNotify);
     case XFA_ATTRIBUTETYPE_Integer:
       return SetInteger(pAttr->eName,
                         FXSYS_round(FXSYS_wcstof(wsValue.c_str(),
                                                  wsValue.GetLength(), nullptr)),
                         bNotify);
     case XFA_ATTRIBUTETYPE_Measure:
       return SetMeasure(pAttr->eName, CXFA_Measurement(wsValue), bNotify);
     default:
       break;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
-                                CFX_WideString& wsValue,
-                                FX_BOOL bUseDefault) {
+bool CXFA_Node::GetAttribute(XFA_ATTRIBUTE eAttr,
+                             CFX_WideString& wsValue,
+                             bool bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttr = XFA_GetAttributeByID(eAttr);
   if (!pAttr) {
-    return FALSE;
+    return false;
   }
   XFA_ATTRIBUTETYPE eType = pAttr->eType;
   if (eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pNotsure =
         XFA_GetNotsureAttribute(GetElementType(), pAttr->eName);
     eType = pNotsure ? pNotsure->eType : XFA_ATTRIBUTETYPE_Cdata;
   }
   switch (eType) {
     case XFA_ATTRIBUTETYPE_Enum: {
       XFA_ATTRIBUTEENUM eValue;
       if (!TryEnum(pAttr->eName, eValue, bUseDefault)) {
-        return FALSE;
+        return false;
       }
       wsValue = GetAttributeEnumByID(eValue)->pName;
-      return TRUE;
+      return true;
     } break;
     case XFA_ATTRIBUTETYPE_Cdata: {
       CFX_WideStringC wsValueC;
       if (!TryCData(pAttr->eName, wsValueC, bUseDefault)) {
-        return FALSE;
+        return false;
       }
       wsValue = wsValueC;
-      return TRUE;
+      return true;
     } break;
     case XFA_ATTRIBUTETYPE_Boolean: {
-      FX_BOOL bValue;
+      bool bValue;
       if (!TryBoolean(pAttr->eName, bValue, bUseDefault)) {
-        return FALSE;
+        return false;
       }
       wsValue = bValue ? FX_WSTRC(L"1") : FX_WSTRC(L"0");
-      return TRUE;
+      return true;
     } break;
     case XFA_ATTRIBUTETYPE_Integer: {
       int32_t iValue;
       if (!TryInteger(pAttr->eName, iValue, bUseDefault)) {
-        return FALSE;
+        return false;
       }
       wsValue.Format(L"%d", iValue);
-      return TRUE;
+      return true;
     } break;
     case XFA_ATTRIBUTETYPE_Measure: {
       CXFA_Measurement mValue;
       if (!TryMeasure(pAttr->eName, mValue, bUseDefault)) {
-        return FALSE;
+        return false;
       }
       mValue.ToString(wsValue);
-      return TRUE;
+      return true;
     } break;
     default:
       break;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr,
-                                const CFX_WideStringC& wsValue,
-                                bool bNotify) {
+bool CXFA_Node::SetAttribute(const CFX_WideStringC& wsAttr,
+                             const CFX_WideStringC& wsValue,
+                             bool bNotify) {
   const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsValue);
   if (pAttributeInfo) {
     return SetAttribute(pAttributeInfo->eName, wsValue, bNotify);
   }
   void* pKey = GetMapKey_Custom(wsAttr);
   SetMapModuleString(pKey, wsValue);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr,
-                                CFX_WideString& wsValue,
-                                FX_BOOL bUseDefault) {
+bool CXFA_Node::GetAttribute(const CFX_WideStringC& wsAttr,
+                             CFX_WideString& wsValue,
+                             bool bUseDefault) {
   const XFA_ATTRIBUTEINFO* pAttributeInfo = XFA_GetAttributeByName(wsAttr);
   if (pAttributeInfo) {
     return GetAttribute(pAttributeInfo->eName, wsValue, bUseDefault);
   }
   void* pKey = GetMapKey_Custom(wsAttr);
   CFX_WideStringC wsValueC;
   if (GetMapModuleString(pKey, wsValueC)) {
     wsValue = wsValueC;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) {
+bool CXFA_Node::RemoveAttribute(const CFX_WideStringC& wsAttr) {
   void* pKey = GetMapKey_Custom(wsAttr);
   RemoveMapModuleKey(pKey);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr,
-                              FX_BOOL& bValue,
-                              FX_BOOL bUseDefault) {
+bool CXFA_Node::TryBoolean(XFA_ATTRIBUTE eAttr,
+                           bool& bValue,
+                           bool bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Boolean, bUseDefault, pValue))
-    return FALSE;
+    return false;
   bValue = !!pValue;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr,
-                              int32_t& iValue,
-                              FX_BOOL bUseDefault) {
+bool CXFA_Node::TryInteger(XFA_ATTRIBUTE eAttr,
+                           int32_t& iValue,
+                           bool bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Integer, bUseDefault, pValue))
-    return FALSE;
+    return false;
   iValue = (int32_t)(uintptr_t)pValue;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr,
-                           XFA_ATTRIBUTEENUM& eValue,
-                           FX_BOOL bUseDefault) {
+bool CXFA_Node::TryEnum(XFA_ATTRIBUTE eAttr,
+                        XFA_ATTRIBUTEENUM& eValue,
+                        bool bUseDefault) {
   void* pValue = nullptr;
   if (!GetValue(eAttr, XFA_ATTRIBUTETYPE_Enum, bUseDefault, pValue))
-    return FALSE;
+    return false;
   eValue = (XFA_ATTRIBUTEENUM)(uintptr_t)pValue;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
-                              CXFA_Measurement mValue,
-                              bool bNotify) {
+bool CXFA_Node::SetMeasure(XFA_ATTRIBUTE eAttr,
+                           CXFA_Measurement mValue,
+                           bool bNotify) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleBuffer(pKey, &mValue, sizeof(CXFA_Measurement));
-  OnChanged(eAttr, bNotify, FALSE);
-  return TRUE;
+  OnChanged(eAttr, bNotify, false);
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
-                              CXFA_Measurement& mValue,
-                              FX_BOOL bUseDefault) const {
+bool CXFA_Node::TryMeasure(XFA_ATTRIBUTE eAttr,
+                           CXFA_Measurement& mValue,
+                           bool bUseDefault) const {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   void* pValue;
   int32_t iBytes;
   if (GetMapModuleBuffer(pKey, pValue, iBytes) && iBytes == sizeof(mValue)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
-    return TRUE;
+    return true;
   }
   if (bUseDefault &&
       XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Measure, m_ePacket)) {
     FXSYS_memcpy(&mValue, pValue, sizeof(mValue));
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 CXFA_Measurement CXFA_Node::GetMeasure(XFA_ATTRIBUTE eAttr) const {
   CXFA_Measurement mValue;
-  return TryMeasure(eAttr, mValue, TRUE) ? mValue : CXFA_Measurement();
+  return TryMeasure(eAttr, mValue, true) ? mValue : CXFA_Measurement();
 }
 
-FX_BOOL CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
-                            const CFX_WideString& wsValue,
-                            bool bNotify,
-                            FX_BOOL bScriptModify) {
+bool CXFA_Node::SetCData(XFA_ATTRIBUTE eAttr,
+                         const CFX_WideString& wsValue,
+                         bool bNotify,
+                         bool bScriptModify) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pClone = new CFX_WideString(wsValue);
     SetUserData(pKey, pClone, &deleteWideStringCallBack);
   } else {
     SetMapModuleString(pKey, wsValue.AsStringC());
     if (eAttr == XFA_ATTRIBUTE_Name)
       UpdateNameHash();
   }
   OnChanged(eAttr, bNotify, bScriptModify);
 
   if (!IsNeedSavingXMLNode() || eAttr == XFA_ATTRIBUTE_QualifiedName ||
       eAttr == XFA_ATTRIBUTE_BindingNode) {
-    return TRUE;
+    return true;
   }
 
   if (eAttr == XFA_ATTRIBUTE_Name &&
       (m_elementType == XFA_Element::DataValue ||
        m_elementType == XFA_Element::DataGroup)) {
-    return TRUE;
+    return true;
   }
 
   if (eAttr == XFA_ATTRIBUTE_Value) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)),
                           wsValue);
         } else {
-          FX_BOOL bDeleteChildren = TRUE;
+          bool bDeleteChildren = true;
           if (GetPacketID() == XFA_XDPPACKET_Datasets) {
             for (CXFA_Node* pChildDataNode =
                      GetNodeItem(XFA_NODEITEM_FirstChild);
                  pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                      XFA_NODEITEM_NextSibling)) {
               CXFA_NodeArray formNodes;
               if (pChildDataNode->GetBindItems(formNodes) > 0) {
-                bDeleteChildren = FALSE;
+                bDeleteChildren = false;
                 break;
               }
             }
           }
           if (bDeleteChildren) {
             static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
           }
           static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsValue);
         }
         break;
       case FDE_XMLNODE_Text:
         static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsValue);
         break;
       default:
         ASSERT(0);
     }
-    return TRUE;
+    return true;
   }
 
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
   if (pInfo) {
     ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     CFX_WideString wsAttrName = pInfo->pName;
     if (pInfo->eName == XFA_ATTRIBUTE_ContentType) {
       wsAttrName = FX_WSTRC(L"xfa:") + wsAttrName;
     }
     static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetString(wsAttrName, wsValue);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
-                                     const CFX_WideString& wsXMLValue,
-                                     bool bNotify,
-                                     FX_BOOL bScriptModify) {
+bool CXFA_Node::SetAttributeValue(const CFX_WideString& wsValue,
+                                  const CFX_WideString& wsXMLValue,
+                                  bool bNotify,
+                                  bool bScriptModify) {
   void* pKey = GetMapKey_Element(GetElementType(), XFA_ATTRIBUTE_Value);
   OnChanging(XFA_ATTRIBUTE_Value, bNotify);
   CFX_WideString* pClone = new CFX_WideString(wsValue);
   SetUserData(pKey, pClone, &deleteWideStringCallBack);
   OnChanged(XFA_ATTRIBUTE_Value, bNotify, bScriptModify);
   if (IsNeedSavingXMLNode()) {
     FDE_XMLNODETYPE eXMLType = m_pXMLNode->GetType();
     switch (eXMLType) {
       case FDE_XMLNODE_Element:
         if (IsAttributeInXML()) {
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(CFX_WideString(GetCData(XFA_ATTRIBUTE_QualifiedName)),
                           wsXMLValue);
         } else {
-          FX_BOOL bDeleteChildren = TRUE;
+          bool bDeleteChildren = true;
           if (GetPacketID() == XFA_XDPPACKET_Datasets) {
             for (CXFA_Node* pChildDataNode =
                      GetNodeItem(XFA_NODEITEM_FirstChild);
                  pChildDataNode; pChildDataNode = pChildDataNode->GetNodeItem(
                                      XFA_NODEITEM_NextSibling)) {
               CXFA_NodeArray formNodes;
               if (pChildDataNode->GetBindItems(formNodes) > 0) {
-                bDeleteChildren = FALSE;
+                bDeleteChildren = false;
                 break;
               }
             }
           }
           if (bDeleteChildren) {
             static_cast<CFDE_XMLElement*>(m_pXMLNode)->DeleteChildren();
           }
           static_cast<CFDE_XMLElement*>(m_pXMLNode)->SetTextData(wsXMLValue);
         }
         break;
       case FDE_XMLNODE_Text:
         static_cast<CFDE_XMLText*>(m_pXMLNode)->SetText(wsXMLValue);
         break;
       default:
         ASSERT(0);
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
-                            CFX_WideString& wsValue,
-                            FX_BOOL bUseDefault,
-                            FX_BOOL bProto) {
+bool CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
+                         CFX_WideString& wsValue,
+                         bool bUseDefault,
+                         bool bProto) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = *pStr;
-      return TRUE;
+      return true;
     }
   } else {
     CFX_WideStringC wsValueC;
     if (GetMapModuleString(pKey, wsValueC)) {
       wsValue = wsValueC;
-      return TRUE;
+      return true;
     }
   }
   if (!bUseDefault) {
-    return FALSE;
+    return false;
   }
   void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (const FX_WCHAR*)pValue;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
-                            CFX_WideStringC& wsValue,
-                            FX_BOOL bUseDefault,
-                            FX_BOOL bProto) {
+bool CXFA_Node::TryCData(XFA_ATTRIBUTE eAttr,
+                         CFX_WideStringC& wsValue,
+                         bool bUseDefault,
+                         bool bProto) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (eAttr == XFA_ATTRIBUTE_Value) {
     CFX_WideString* pStr = (CFX_WideString*)GetUserData(pKey, bProto);
     if (pStr) {
       wsValue = pStr->AsStringC();
-      return TRUE;
+      return true;
     }
   } else {
     if (GetMapModuleString(pKey, wsValue)) {
-      return TRUE;
+      return true;
     }
   }
   if (!bUseDefault) {
-    return FALSE;
+    return false;
   }
   void* pValue = nullptr;
   if (XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr,
                                    XFA_ATTRIBUTETYPE_Cdata, m_ePacket)) {
     wsValue = (CFX_WideStringC)(const FX_WCHAR*)pValue;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
-                             void* pData,
-                             XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
+bool CXFA_Node::SetObject(XFA_ATTRIBUTE eAttr,
+                          void* pData,
+                          XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   return SetUserData(pKey, pData, pCallbackInfo);
 }
 
-FX_BOOL CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
+bool CXFA_Node::TryObject(XFA_ATTRIBUTE eAttr, void*& pData) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   pData = GetUserData(pKey);
   return !!pData;
 }
 
-FX_BOOL CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
-                            XFA_ATTRIBUTETYPE eType,
-                            void* pValue,
-                            bool bNotify) {
+bool CXFA_Node::SetValue(XFA_ATTRIBUTE eAttr,
+                         XFA_ATTRIBUTETYPE eType,
+                         void* pValue,
+                         bool bNotify) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   OnChanging(eAttr, bNotify);
   SetMapModuleValue(pKey, pValue);
-  OnChanged(eAttr, bNotify, FALSE);
+  OnChanged(eAttr, bNotify, false);
   if (IsNeedSavingXMLNode()) {
     ASSERT(m_pXMLNode->GetType() == FDE_XMLNODE_Element);
     const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttr);
     if (pInfo) {
       switch (eType) {
         case XFA_ATTRIBUTETYPE_Enum:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(
                   pInfo->pName,
                   GetAttributeEnumByID((XFA_ATTRIBUTEENUM)(uintptr_t)pValue)
                       ->pName);
           break;
         case XFA_ATTRIBUTETYPE_Boolean:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetString(pInfo->pName, pValue ? L"1" : L"0");
           break;
         case XFA_ATTRIBUTETYPE_Integer:
           static_cast<CFDE_XMLElement*>(m_pXMLNode)
               ->SetInteger(pInfo->pName, (int32_t)(uintptr_t)pValue);
           break;
         default:
           ASSERT(0);
       }
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
-                            XFA_ATTRIBUTETYPE eType,
-                            FX_BOOL bUseDefault,
-                            void*& pValue) {
+bool CXFA_Node::GetValue(XFA_ATTRIBUTE eAttr,
+                         XFA_ATTRIBUTETYPE eType,
+                         bool bUseDefault,
+                         void*& pValue) {
   void* pKey = GetMapKey_Element(GetElementType(), eAttr);
   if (GetMapModuleValue(pKey, pValue)) {
-    return TRUE;
+    return true;
   }
   if (!bUseDefault) {
-    return FALSE;
+    return false;
   }
   return XFA_GetAttributeDefaultValue(pValue, GetElementType(), eAttr, eType,
                                       m_ePacket);
 }
 
-FX_BOOL CXFA_Node::SetUserData(void* pKey,
-                               void* pData,
-                               XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
+bool CXFA_Node::SetUserData(void* pKey,
+                            void* pData,
+                            XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   SetMapModuleBuffer(pKey, &pData, sizeof(void*),
                      pCallbackInfo ? pCallbackInfo : &gs_XFADefaultFreeData);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::TryUserData(void* pKey, void*& pData, FX_BOOL bProtoAlso) {
+bool CXFA_Node::TryUserData(void* pKey, void*& pData, bool bProtoAlso) {
   int32_t iBytes = 0;
   if (!GetMapModuleBuffer(pKey, pData, iBytes, bProtoAlso)) {
-    return FALSE;
+    return false;
   }
   return iBytes == sizeof(void*) && FXSYS_memcpy(&pData, pData, iBytes);
 }
 
-FX_BOOL CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
-                                    const CFX_WideString& wsXMLValue,
-                                    bool bNotify,
-                                    FX_BOOL bScriptModify,
-                                    FX_BOOL bSyncData) {
+bool CXFA_Node::SetScriptContent(const CFX_WideString& wsContent,
+                                 const CFX_WideString& wsXMLValue,
+                                 bool bNotify,
+                                 bool bScriptModify,
+                                 bool bSyncData) {
   CXFA_Node* pNode = nullptr;
   CXFA_Node* pBindNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode: {
       if (XFA_FieldIsMultiListBox(this)) {
         CXFA_Node* pValue = GetProperty(0, XFA_Element::Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetCData(XFA_ATTRIBUTE_ContentType, L"text/xml");
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
-                                      bScriptModify, FALSE);
+                                      bScriptModify, false);
         CXFA_Node* pBind = GetBindData();
         if (bSyncData && pBind) {
           CFX_WideStringArray wsSaveTextArray;
           int32_t iSize = 0;
           if (!wsContent.IsEmpty()) {
             int32_t iStart = 0;
             int32_t iLength = wsContent.GetLength();
             int32_t iEnd = wsContent.Find(L'\n', iStart);
             iEnd = (iEnd == -1) ? iLength : iEnd;
             while (iEnd >= iStart) {
@@ skipping 34 matching lines @@
               while (iDelNodes-- > 0) {
                 pBind->RemoveChild(pBind->GetNodeItem(XFA_NODEITEM_FirstChild));
               }
             }
             int32_t i = 0;
             for (CXFA_Node* pValueNode =
                      pBind->GetNodeItem(XFA_NODEITEM_FirstChild);
                  pValueNode; pValueNode = pValueNode->GetNodeItem(
                                  XFA_NODEITEM_NextSibling)) {
               pValueNode->SetAttributeValue(wsSaveTextArray[i],
-                                            wsSaveTextArray[i], FALSE);
+                                            wsSaveTextArray[i], false);
               i++;
             }
           }
           CXFA_NodeArray nodeArray;
           pBind->GetBindItems(nodeArray);
           for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
             if (nodeArray[i] != this) {
               nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify,
-                                             bScriptModify, FALSE);
+                                             bScriptModify, false);
             }
           }
         }
         break;
       } else if (GetElementType() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetProperty(0, XFA_Element::Value);
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         ASSERT(pChildValue);
         pChildValue->SetScriptContent(wsContent, wsContent, bNotify,
-                                      bScriptModify, FALSE);
+                                      bScriptModify, false);
       }
       pBindNode = GetBindData();
       if (pBindNode && bSyncData) {
         pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
-                                    bScriptModify, FALSE);
+                                    bScriptModify, false);
         CXFA_NodeArray nodeArray;
         pBindNode->GetBindItems(nodeArray);
         for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
           if (nodeArray[i] != this) {
             nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify, true,
-                                           FALSE);
+                                           false);
           }
         }
       }
       pBindNode = nullptr;
       break;
     }
     case XFA_ObjectType::ContentNode: {
       CFX_WideString wsContentType;
       if (GetElementType() == XFA_Element::ExData) {
-        GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+        GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, false);
         if (wsContentType == FX_WSTRC(L"text/html")) {
           wsContentType = FX_WSTRC(L"");
           SetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType.AsStringC());
         }
       }
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         pContentRawDataNode = CreateSamePacketNode(
             (wsContentType == FX_WSTRC(L"text/xml")) ? XFA_Element::Sharpxml
                                                      : XFA_Element::Sharptext);
@@ skipping 12 matching lines @@
         CXFA_Node* pParent = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParent) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
         }
         if (pParent && pParent->GetElementType() == XFA_Element::Value) {
           pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
           if (pParent && pParent->IsContainerNode()) {
             pBindNode = pParent->GetBindData();
             if (pBindNode) {
               pBindNode->SetScriptContent(wsContent, wsXMLValue, bNotify,
-                                          bScriptModify, FALSE);
+                                          bScriptModify, false);
             }
           }
         }
       }
       break;
     default:
       if (GetElementType() == XFA_Element::DataValue) {
         pNode = this;
         pBindNode = this;
       }
       break;
   }
   if (pNode) {
     SetAttributeValue(wsContent, wsXMLValue, bNotify, bScriptModify);
     if (pBindNode && bSyncData) {
       CXFA_NodeArray nodeArray;
       pBindNode->GetBindItems(nodeArray);
       for (int32_t i = 0; i < nodeArray.GetSize(); i++) {
         nodeArray[i]->SetScriptContent(wsContent, wsContent, bNotify,
-                                       bScriptModify, FALSE);
+                                       bScriptModify, false);
       }
     }
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_Node::SetContent(const CFX_WideString& wsContent,
-                              const CFX_WideString& wsXMLValue,
-                              bool bNotify,
-                              FX_BOOL bScriptModify,
-                              FX_BOOL bSyncData) {
+bool CXFA_Node::SetContent(const CFX_WideString& wsContent,
+                           const CFX_WideString& wsXMLValue,
+                           bool bNotify,
+                           bool bScriptModify,
+                           bool bSyncData) {
   return SetScriptContent(wsContent, wsXMLValue, bNotify, bScriptModify,
                           bSyncData);
 }
 
-CFX_WideString CXFA_Node::GetScriptContent(FX_BOOL bScriptModify) {
+CFX_WideString CXFA_Node::GetScriptContent(bool bScriptModify) {
   CFX_WideString wsContent;
   return TryContent(wsContent, bScriptModify) ? wsContent : CFX_WideString();
 }
 
 CFX_WideString CXFA_Node::GetContent() {
   return GetScriptContent();
 }
 
-FX_BOOL CXFA_Node::TryContent(CFX_WideString& wsContent,
-                              FX_BOOL bScriptModify,
-                              FX_BOOL bProto) {
+bool CXFA_Node::TryContent(CFX_WideString& wsContent,
+                           bool bScriptModify,
+                           bool bProto) {
   CXFA_Node* pNode = nullptr;
   switch (GetObjectType()) {
     case XFA_ObjectType::ContainerNode:
       if (GetElementType() == XFA_Element::ExclGroup) {
         pNode = this;
       } else {
         CXFA_Node* pValue = GetChild(0, XFA_Element::Value);
         if (!pValue) {
-          return FALSE;
+          return false;
         }
         CXFA_Node* pChildValue = pValue->GetNodeItem(XFA_NODEITEM_FirstChild);
         if (pChildValue && XFA_FieldIsMultiListBox(this)) {
           pChildValue->SetAttribute(XFA_ATTRIBUTE_ContentType,
                                     FX_WSTRC(L"text/xml"));
         }
         return pChildValue
                    ? pChildValue->TryContent(wsContent, bScriptModify, bProto)
-                   : FALSE;
+                   : false;
       }
       break;
     case XFA_ObjectType::ContentNode: {
       CXFA_Node* pContentRawDataNode = GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!pContentRawDataNode) {
         XFA_Element element = XFA_Element::Sharptext;
         if (GetElementType() == XFA_Element::ExData) {
           CFX_WideString wsContentType;
-          GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, FALSE);
+          GetAttribute(XFA_ATTRIBUTE_ContentType, wsContentType, false);
           if (wsContentType == FX_WSTRC(L"text/html")) {
             element = XFA_Element::SharpxHTML;
           } else if (wsContentType == FX_WSTRC(L"text/xml")) {
             element = XFA_Element::Sharpxml;
           }
         }
         pContentRawDataNode = CreateSamePacketNode(element);
         InsertChild(pContentRawDataNode);
       }
       return pContentRawDataNode->TryContent(wsContent, bScriptModify, bProto);
     }
     case XFA_ObjectType::NodeC:
     case XFA_ObjectType::NodeV:
     case XFA_ObjectType::TextNode:
       pNode = this;
     default:
       if (GetElementType() == XFA_Element::DataValue) {
         pNode = this;
       }
       break;
   }
   if (pNode) {
     if (bScriptModify) {
       CXFA_ScriptContext* pScriptContext = m_pDocument->GetScriptContext();
       if (pScriptContext) {
         m_pDocument->GetScriptContext()->AddNodesOfRunScript(this);
       }
     }
-    return TryCData(XFA_ATTRIBUTE_Value, wsContent, FALSE, bProto);
+    return TryCData(XFA_ATTRIBUTE_Value, wsContent, false, bProto);
   }
-  return FALSE;
+  return false;
 }
 
 CXFA_Node* CXFA_Node::GetModelNode() {
   switch (GetPacketID()) {
     case XFA_XDPPACKET_XDP:
       return m_pDocument->GetRoot();
     case XFA_XDPPACKET_Config:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config));
     case XFA_XDPPACKET_Template:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Template));
     case XFA_XDPPACKET_Form:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Form));
     case XFA_XDPPACKET_Datasets:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Datasets));
     case XFA_XDPPACKET_LocaleSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_LocaleSet));
     case XFA_XDPPACKET_ConnectionSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_ConnectionSet));
     case XFA_XDPPACKET_SourceSet:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_SourceSet));
     case XFA_XDPPACKET_Xdc:
       return ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Xdc));
     default:
       return this;
   }
 }
 
-FX_BOOL CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
+bool CXFA_Node::TryNamespace(CFX_WideString& wsNamespace) {
   wsNamespace.clear();
   if (IsModelNode() || GetElementType() == XFA_Element::Packet) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode || pXMLNode->GetType() != FDE_XMLNODE_Element) {
-      return FALSE;
+      return false;
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
-    return TRUE;
+    return true;
   } else if (GetPacketID() == XFA_XDPPACKET_Datasets) {
     CFDE_XMLNode* pXMLNode = GetXMLMappingNode();
     if (!pXMLNode) {
-      return FALSE;
+      return false;
     }
     if (pXMLNode->GetType() != FDE_XMLNODE_Element) {
-      return TRUE;
+      return true;
     }
     if (GetElementType() == XFA_Element::DataValue &&
         GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData) {
       return XFA_FDEExtension_ResolveNamespaceQualifier(
           static_cast<CFDE_XMLElement*>(pXMLNode),
           GetCData(XFA_ATTRIBUTE_QualifiedName), wsNamespace);
     }
     static_cast<CFDE_XMLElement*>(pXMLNode)->GetNamespaceURI(wsNamespace);
-    return TRUE;
+    return true;
   } else {
     CXFA_Node* pModelNode = GetModelNode();
     return pModelNode->TryNamespace(wsNamespace);
   }
 }
 
 CXFA_Node* CXFA_Node::GetProperty(int32_t index,
                                   XFA_Element eProperty,
-                                  FX_BOOL bCreateProperty) {
+                                  bool bCreateProperty) {
   XFA_Element eType = GetElementType();
   uint32_t dwPacket = GetPacketID();
   const XFA_PROPERTY* pProperty =
       XFA_GetPropertyOfElement(eType, eProperty, dwPacket);
   if (!pProperty || index >= pProperty->uOccur)
     return nullptr;
 
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
@@ skipping 22 matching lines @@
   for (; iCount <= index; iCount++) {
     pNewNode = m_pDocument->CreateNode(pPacket, eProperty);
     if (!pNewNode)
       return nullptr;
     InsertChild(pNewNode, nullptr);
     pNewNode->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   return pNewNode;
 }
 
-int32_t CXFA_Node::CountChildren(XFA_Element eType, FX_BOOL bOnlyChild) {
+int32_t CXFA_Node::CountChildren(XFA_Element eType, bool bOnlyChild) {
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
     }
   }
   return iCount;
 }
 
 CXFA_Node* CXFA_Node::GetChild(int32_t index,
                                XFA_Element eType,
-                               FX_BOOL bOnlyChild) {
+                               bool bOnlyChild) {
   ASSERT(index > -1);
   CXFA_Node* pNode = m_pChild;
   int32_t iCount = 0;
   for (; pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetElementType() == eType || eType == XFA_Element::Unknown) {
       if (bOnlyChild) {
         const XFA_PROPERTY* pProperty = XFA_GetPropertyOfElement(
             GetElementType(), pNode->GetElementType(), XFA_XDPPACKET_UNKNOWN);
         if (pProperty) {
           continue;
         }
       }
       iCount++;
       if (iCount > index) {
         return pNode;
       }
     }
   }
   return nullptr;
 }
 
 int32_t CXFA_Node::InsertChild(int32_t index, CXFA_Node* pNode) {
   ASSERT(!pNode->m_pNext);
   pNode->m_pParent = this;
-  FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode);
+  bool ret = m_pDocument->RemovePurgeNode(pNode);
   ASSERT(ret);
   (void)ret;  // Avoid unused variable warning.
 
   if (!m_pChild || index == 0) {
     if (index > 0) {
       return -1;
     }
     pNode->m_pNext = m_pChild;
     m_pChild = pNode;
     index = 0;
@@ skipping 23 matching lines @@
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, index);
     pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
   return index;
 }
 
-FX_BOOL CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
+bool CXFA_Node::InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode) {
   if (!pNode || pNode->m_pParent ||
       (pBeforeNode && pBeforeNode->m_pParent != this)) {
     ASSERT(false);
-    return FALSE;
+    return false;
   }
-  FX_BOOL ret = m_pDocument->RemovePurgeNode(pNode);
+  bool ret = m_pDocument->RemovePurgeNode(pNode);
   ASSERT(ret);
   (void)ret;  // Avoid unused variable warning.
 
   int32_t nIndex = -1;
   pNode->m_pParent = this;
   if (!m_pChild || pBeforeNode == m_pChild) {
     pNode->m_pNext = m_pChild;
     m_pChild = pNode;
     nIndex = 0;
   } else if (!pBeforeNode) {
@@ skipping 17 matching lines @@
   pNode->ClearFlag(XFA_NodeFlag_HasRemovedChildren);
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify)
     pNotify->OnChildAdded(this);
 
   if (IsNeedSavingXMLNode() && pNode->m_pXMLNode) {
     ASSERT(!pNode->m_pXMLNode->GetNodeItem(CFDE_XMLNode::Parent));
     m_pXMLNode->InsertChildNode(pNode->m_pXMLNode, nIndex);
     pNode->ClearFlag(XFA_NodeFlag_OwnXMLNode);
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_Node* CXFA_Node::Deprecated_GetPrevSibling() {
   if (!m_pParent) {
     return nullptr;
   }
   for (CXFA_Node* pSibling = m_pParent->m_pChild; pSibling;
        pSibling = pSibling->m_pNext) {
     if (pSibling->m_pNext == this) {
       return pSibling;
     }
   }
   return nullptr;
 }
 
-FX_BOOL CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) {
+bool CXFA_Node::RemoveChild(CXFA_Node* pNode, bool bNotify) {
   if (!pNode || pNode->m_pParent != this) {
-    ASSERT(FALSE);
-    return FALSE;
+    ASSERT(false);
+    return false;
   }
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
     if (m_pLastChild == pNode) {
       m_pLastChild = pNode->m_pNext;
     }
     pNode->m_pNext = nullptr;
     pNode->m_pParent = nullptr;
   } else {
     CXFA_Node* pPrev = pNode->Deprecated_GetPrevSibling();
@@ skipping 13 matching lines @@
       ASSERT(pNode->m_pXMLNode == m_pXMLNode &&
              m_pXMLNode->GetType() == FDE_XMLNODE_Element);
       if (pNode->m_pXMLNode->GetType() == FDE_XMLNODE_Element) {
         CFDE_XMLElement* pXMLElement =
             static_cast<CFDE_XMLElement*>(pNode->m_pXMLNode);
         CFX_WideStringC wsAttributeName =
             pNode->GetCData(XFA_ATTRIBUTE_QualifiedName);
         pXMLElement->RemoveAttribute(wsAttributeName.c_str());
       }
       CFX_WideString wsName;
-      pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, FALSE);
+      pNode->GetAttribute(XFA_ATTRIBUTE_Name, wsName, false);
       CFDE_XMLElement* pNewXMLElement = new CFDE_XMLElement(wsName);
       CFX_WideStringC wsValue = GetCData(XFA_ATTRIBUTE_Value);
       if (!wsValue.IsEmpty()) {
         pNewXMLElement->SetTextData(CFX_WideString(wsValue));
       }
       pNode->m_pXMLNode = pNewXMLElement;
       pNode->SetEnum(XFA_ATTRIBUTE_Contains, XFA_ATTRIBUTEENUM_Unknown);
     } else {
       m_pXMLNode->RemoveChildNode(pNode->m_pXMLNode);
     }
     pNode->SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_Node* CXFA_Node::GetFirstChildByName(const CFX_WideStringC& wsName) const {
   return GetFirstChildByName(FX_HashCode_GetW(wsName, false));
 }
 
 CXFA_Node* CXFA_Node::GetFirstChildByName(uint32_t dwNameHash) const {
   for (CXFA_Node* pNode = GetNodeItem(XFA_NODEITEM_FirstChild); pNode;
        pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pNode->GetNameHash() == dwNameHash) {
@@ skipping 109 matching lines @@
       pNotify->OnNodeReady(this);
     }
   }
   m_uNodeFlags |= dwFlag;
 }
 
 void CXFA_Node::ClearFlag(uint32_t dwFlag) {
   m_uNodeFlags &= ~dwFlag;
 }
 
-FX_BOOL CXFA_Node::IsAttributeInXML() {
+bool CXFA_Node::IsAttributeInXML() {
   return GetEnum(XFA_ATTRIBUTE_Contains) == XFA_ATTRIBUTEENUM_MetaData;
 }
 
 void CXFA_Node::OnRemoved(bool bNotify) {
   if (!bNotify)
     return;
 
   CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
   if (pNotify)
     pNotify->OnChildRemoved();
 }
 
 void CXFA_Node::OnChanging(XFA_ATTRIBUTE eAttr, bool bNotify) {
   if (bNotify && IsInitialized()) {
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (pNotify) {
       pNotify->OnValueChanging(this, eAttr);
     }
   }
 }
 
 void CXFA_Node::OnChanged(XFA_ATTRIBUTE eAttr,
                           bool bNotify,
-                          FX_BOOL bScriptModify) {
+                          bool bScriptModify) {
   if (bNotify && IsInitialized()) {
     Script_Attribute_SendAttributeChangeMessage(eAttr, bScriptModify);
   }
 }
 
 int32_t CXFA_Node::execSingleEventByName(const CFX_WideStringC& wsEventName,
                                          XFA_Element eType) {
   int32_t iRet = XFA_EVENTERROR_NotExist;
   const XFA_ExecEventParaInfo* eventParaInfo =
       GetEventParaInfoByName(wsEventName);
   if (eventParaInfo) {
     uint32_t validFlags = eventParaInfo->m_validFlags;
     CXFA_FFNotify* pNotify = m_pDocument->GetNotify();
     if (!pNotify) {
       return iRet;
     }
     if (validFlags == 1) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType);
     } else if (validFlags == 2) {
       iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                           FALSE, FALSE);
+                                           false, false);
     } else if (validFlags == 3) {
       if (eType == XFA_Element::Subform) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
+                                             false, false);
       }
     } else if (validFlags == 4) {
       if (eType == XFA_Element::ExclGroup || eType == XFA_Element::Field) {
         CXFA_Node* pParentNode = GetNodeItem(XFA_NODEITEM_Parent);
         if (pParentNode &&
             pParentNode->GetElementType() == XFA_Element::ExclGroup) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
+                                               false, false);
         }
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
+                                             false, false);
       }
     } else if (validFlags == 5) {
       if (eType == XFA_Element::Field) {
         iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                             FALSE, FALSE);
+                                             false, false);
       }
     } else if (validFlags == 6) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
         if (pUINode->m_elementType == XFA_Element::Signature) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
+                                               false, false);
         }
       }
     } else if (validFlags == 7) {
       CXFA_WidgetData* pWidgetData = GetWidgetData();
       if (pWidgetData) {
         CXFA_Node* pUINode = pWidgetData->GetUIChild();
         if ((pUINode->m_elementType == XFA_Element::ChoiceList) &&
             (!pWidgetData->IsListBox())) {
           iRet = pNotify->ExecEventByDeepFirst(this, eventParaInfo->m_eventType,
-                                               FALSE, FALSE);
+                                               false, false);
         }
       }
     }
   }
   return iRet;
 }
 
 void CXFA_Node::UpdateNameHash() {
   const XFA_NOTSUREATTRIBUTE* pNotsure =
       XFA_GetNotsureAttribute(GetElementType(), XFA_ATTRIBUTE_Name);
   CFX_WideStringC wsName;
   if (!pNotsure || pNotsure->eType == XFA_ATTRIBUTETYPE_Cdata) {
     wsName = GetCData(XFA_ATTRIBUTE_Name);
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   } else if (pNotsure->eType == XFA_ATTRIBUTETYPE_Enum) {
     wsName = GetAttributeEnumByID(GetEnum(XFA_ATTRIBUTE_Name))->pName;
     m_dwNameHash = FX_HashCode_GetW(wsName, false);
   }
 }
 
 CFDE_XMLNode* CXFA_Node::CreateXMLMappingNode() {
   if (!m_pXMLNode) {
     CFX_WideString wsTag(GetCData(XFA_ATTRIBUTE_Name));
     m_pXMLNode = new CFDE_XMLElement(wsTag);
     SetFlag(XFA_NodeFlag_OwnXMLNode, false);
   }
   return m_pXMLNode;
 }
 
-FX_BOOL CXFA_Node::IsNeedSavingXMLNode() {
+bool CXFA_Node::IsNeedSavingXMLNode() {
   return m_pXMLNode && (GetPacketID() == XFA_XDPPACKET_Datasets ||
                         GetElementType() == XFA_Element::Xfa);
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::CreateMapModuleData() {
   if (!m_pMapModuleData)
     m_pMapModuleData = new XFA_MAPMODULEDATA;
   return m_pMapModuleData;
 }
 
 XFA_MAPMODULEDATA* CXFA_Node::GetMapModuleData() const {
   return m_pMapModuleData;
 }
 
 void CXFA_Node::SetMapModuleValue(void* pKey, void* pValue) {
   XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
   pModule->m_ValueMap.SetAt(pKey, pValue);
 }
 
-FX_BOOL CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) {
+bool CXFA_Node::GetMapModuleValue(void* pKey, void*& pValue) {
   CXFA_Node* pNode = this;
   while (pNode) {
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_ValueMap.Lookup(pKey, pValue)) {
-      return TRUE;
+      return true;
     }
     pNode = pNode->GetPacketID() != XFA_XDPPACKET_Datasets
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_Node::SetMapModuleString(void* pKey, const CFX_WideStringC& wsValue) {
   SetMapModuleBuffer(pKey, (void*)wsValue.c_str(),
                      wsValue.GetLength() * sizeof(FX_WCHAR));
 }
 
-FX_BOOL CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
+bool CXFA_Node::GetMapModuleString(void* pKey, CFX_WideStringC& wsValue) {
   void* pValue;
   int32_t iBytes;
   if (!GetMapModuleBuffer(pKey, pValue, iBytes)) {
-    return FALSE;
+    return false;
   }
   wsValue = CFX_WideStringC((const FX_WCHAR*)pValue, iBytes / sizeof(FX_WCHAR));
-  return TRUE;
+  return true;
 }
 
 void CXFA_Node::SetMapModuleBuffer(
     void* pKey,
     void* pValue,
     int32_t iBytes,
     XFA_MAPDATABLOCKCALLBACKINFO* pCallbackInfo) {
   XFA_MAPMODULEDATA* pModule = CreateMapModuleData();
   XFA_MAPDATABLOCK*& pBuffer = pModule->m_BufferMap[pKey];
   if (!pBuffer) {
     pBuffer =
         (XFA_MAPDATABLOCK*)FX_Alloc(uint8_t, sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->iBytes != iBytes) {
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
       pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
     }
     pBuffer = (XFA_MAPDATABLOCK*)FX_Realloc(uint8_t, pBuffer,
                                             sizeof(XFA_MAPDATABLOCK) + iBytes);
   } else if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pFree) {
     pBuffer->pCallbackInfo->pFree(*(void**)pBuffer->GetData());
   }
   if (!pBuffer)
     return;
 
   pBuffer->pCallbackInfo = pCallbackInfo;
   pBuffer->iBytes = iBytes;
   FXSYS_memcpy(pBuffer->GetData(), pValue, iBytes);
 }
 
-FX_BOOL CXFA_Node::GetMapModuleBuffer(void* pKey,
-                                      void*& pValue,
-                                      int32_t& iBytes,
-                                      FX_BOOL bProtoAlso) const {
+bool CXFA_Node::GetMapModuleBuffer(void* pKey,
+                                   void*& pValue,
+                                   int32_t& iBytes,
+                                   bool bProtoAlso) const {
   XFA_MAPDATABLOCK* pBuffer = nullptr;
   const CXFA_Node* pNode = this;
   while (pNode) {
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule && pModule->m_BufferMap.Lookup(pKey, pBuffer)) {
       break;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
   if (!pBuffer) {
-    return FALSE;
+    return false;
   }
   pValue = pBuffer->GetData();
   iBytes = pBuffer->iBytes;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_Node::HasMapModuleKey(void* pKey, FX_BOOL bProtoAlso) {
+bool CXFA_Node::HasMapModuleKey(void* pKey, bool bProtoAlso) {
   CXFA_Node* pNode = this;
   while (pNode) {
     void* pVal;
     XFA_MAPMODULEDATA* pModule = pNode->GetMapModuleData();
     if (pModule &&
         (pModule->m_ValueMap.Lookup(pKey, pVal) ||
          pModule->m_BufferMap.Lookup(pKey, (XFA_MAPDATABLOCK*&)pVal))) {
-      return TRUE;
+      return true;
     }
     pNode = (bProtoAlso && pNode->GetPacketID() != XFA_XDPPACKET_Datasets)
                 ? pNode->GetTemplateNode()
                 : nullptr;
   }
-  return FALSE;
+  return false;
 }
 
 void CXFA_Node::RemoveMapModuleKey(void* pKey) {
   XFA_MAPMODULEDATA* pModule = GetMapModuleData();
   if (!pModule)
     return;
 
   if (pKey) {
     XFA_MAPDATABLOCK* pBuffer = nullptr;
     pModule->m_BufferMap.Lookup(pKey, pBuffer);
@@ skipping 16 matching lines @@
         }
         FX_Free(pBuffer);
       }
     }
     pModule->m_BufferMap.RemoveAll();
     pModule->m_ValueMap.RemoveAll();
     delete pModule;
   }
 }
 
-void CXFA_Node::MergeAllData(void* pDstModule, FX_BOOL bUseSrcAttr) {
+void CXFA_Node::MergeAllData(void* pDstModule, bool bUseSrcAttr) {
   XFA_MAPMODULEDATA* pDstModuleData =
       static_cast<CXFA_Node*>(pDstModule)->CreateMapModuleData();
   XFA_MAPMODULEDATA* pSrcModuleData = GetMapModuleData();
   if (!pSrcModuleData) {
     return;
   }
   FX_POSITION psValue = pSrcModuleData->m_ValueMap.GetStartPosition();
   while (psValue) {
     void* pKey;
     void* pValue;
@@ skipping 40 matching lines @@
     if (pBuffer->pCallbackInfo && pBuffer->pCallbackInfo->pCopy) {
       pBuffer->pCallbackInfo->pCopy(*(void**)pBuffer->GetData());
     }
   }
 }
 
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pDstModule, void* pKey) {
   if (!pDstModule) {
     return;
   }
-  FX_BOOL bNeedMove = TRUE;
+  bool bNeedMove = true;
   if (!pKey) {
-    bNeedMove = FALSE;
+    bNeedMove = false;
   }
   if (pDstModule->GetElementType() != GetElementType()) {
-    bNeedMove = FALSE;
+    bNeedMove = false;
   }
   XFA_MAPMODULEDATA* pSrcModuleData = nullptr;
   XFA_MAPMODULEDATA* pDstModuleData = nullptr;
   if (bNeedMove) {
     pSrcModuleData = GetMapModuleData();
     if (!pSrcModuleData) {
-      bNeedMove = FALSE;
+      bNeedMove = false;
     }
     pDstModuleData = pDstModule->CreateMapModuleData();
   }
   if (bNeedMove) {
     void* pBufferBlockData = pSrcModuleData->m_BufferMap.GetValueAt(pKey);
     if (pBufferBlockData) {
       pSrcModuleData->m_BufferMap.RemoveKey(pKey);
       pDstModuleData->m_BufferMap.RemoveKey(pKey);
       pDstModuleData->m_BufferMap.SetAt(pKey,
                                         (XFA_MAPDATABLOCK*)pBufferBlockData);
     }
   }
   if (pDstModule->IsNodeV()) {
-    CFX_WideString wsValue = pDstModule->GetScriptContent(FALSE);
+    CFX_WideString wsValue = pDstModule->GetScriptContent(false);
     CFX_WideString wsFormatValue(wsValue);
     CXFA_WidgetData* pWidgetData = pDstModule->GetContainerWidgetData();
     if (pWidgetData) {
       pWidgetData->GetFormatDataValue(wsValue, wsFormatValue);
     }
-    pDstModule->SetScriptContent(wsValue, wsFormatValue, true, TRUE);
+    pDstModule->SetScriptContent(wsValue, wsFormatValue, true, true);
   }
 }
 
 void CXFA_Node::MoveBufferMapData(CXFA_Node* pSrcModule,
                                   CXFA_Node* pDstModule,
                                   void* pKey,
-                                  FX_BOOL bRecursive) {
+                                  bool bRecursive) {
   if (!pSrcModule || !pDstModule || !pKey) {
     return;
   }
   if (bRecursive) {
     CXFA_Node* pSrcChild = pSrcModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     CXFA_Node* pDstChild = pDstModule->GetNodeItem(XFA_NODEITEM_FirstChild);
     for (; pSrcChild && pDstChild;
          pSrcChild = pSrcChild->GetNodeItem(XFA_NODEITEM_NextSibling),
          pDstChild = pDstChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
-      MoveBufferMapData(pSrcChild, pDstChild, pKey, TRUE);
+      MoveBufferMapData(pSrcChild, pDstChild, pKey, true);
     }
   }
   pSrcModule->MoveBufferMapData(pDstModule, pKey);
 }