Remove FX_BOOL from xfa.

xfa/fxfa/parser/cxfa_layoutpagemgr.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/parser/cxfa_layoutpagemgr.h"
 
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/cxfa_containerlayoutitem.h"
@@ skipping 67 matching lines @@
       (dwRelevant != XFA_WidgetStatus_Printable)) {
     dwRelevant &= ~XFA_WidgetStatus_Printable;
   }
   return dwRelevant;
 }
 
 void SyncContainer(CXFA_FFNotify* pNotify,
                    CXFA_LayoutProcessor* pDocLayout,
                    CXFA_LayoutItem* pContainerItem,
                    uint32_t dwRelevant,
-                   FX_BOOL bVisible,
+                   bool bVisible,
                    int32_t nPageIndex) {
-  FX_BOOL bVisibleItem = FALSE;
+  bool bVisibleItem = false;
   uint32_t dwStatus = 0;
   uint32_t dwRelevantContainer = 0;
   if (bVisible) {
     XFA_ATTRIBUTEENUM eAttributeValue =
         pContainerItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence);
     if (eAttributeValue == XFA_ATTRIBUTEENUM_Visible ||
         eAttributeValue == XFA_ATTRIBUTEENUM_Unknown) {
-      bVisibleItem = TRUE;
+      bVisibleItem = true;
     }
     dwRelevantContainer = GetRelevant(pContainerItem->m_pFormNode, dwRelevant);
     dwStatus =
         (bVisibleItem ? XFA_WidgetStatus_Visible : 0) | dwRelevantContainer;
   }
   pNotify->OnLayoutItemAdded(pDocLayout, pContainerItem, nPageIndex, dwStatus);
   for (CXFA_LayoutItem* pChild = pContainerItem->m_pFirstChild; pChild;
        pChild = pChild->m_pNextSibling) {
     if (pChild->IsContentLayoutItem()) {
       SyncContainer(pNotify, pDocLayout, pChild, dwRelevantContainer,
@@ skipping 15 matching lines @@
 void RemoveLayoutItem(CXFA_ContainerLayoutItem* pLayoutItem) {
   CXFA_ContainerLayoutItem* pParentLayoutItem =
       static_cast<CXFA_ContainerLayoutItem*>(pLayoutItem->m_pParent);
   if (!pParentLayoutItem)
     return;
 
   pParentLayoutItem->RemoveChild(pLayoutItem);
 }
 
 CXFA_Node* ResolveBreakTarget(CXFA_Node* pPageSetRoot,
-                              FX_BOOL bNewExprStyle,
+                              bool bNewExprStyle,
                               CFX_WideStringC& wsTargetExpr) {
   CXFA_Document* pDocument = pPageSetRoot->GetDocument();
   if (wsTargetExpr.IsEmpty())
     return nullptr;
 
   CFX_WideString wsTargetAll(wsTargetExpr);
   wsTargetAll.TrimLeft();
   wsTargetAll.TrimRight();
   int32_t iSpliteIndex = 0;
-  FX_BOOL bTargetAllFind = TRUE;
+  bool bTargetAllFind = true;
   while (iSpliteIndex != -1) {
     CFX_WideString wsExpr;
     int32_t iSpliteNextIndex = 0;
     if (!bTargetAllFind) {
       iSpliteNextIndex = wsTargetAll.Find(' ', iSpliteIndex);
       wsExpr = wsTargetAll.Mid(iSpliteIndex, iSpliteNextIndex - iSpliteIndex);
     } else {
       wsExpr = wsTargetAll;
     }
     if (wsExpr.IsEmpty())
       return nullptr;
 
-    bTargetAllFind = FALSE;
+    bTargetAllFind = false;
     if (wsExpr.GetAt(0) == '#') {
       CXFA_Node* pNode = pDocument->GetNodeByID(
           ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Template)),
           wsExpr.Mid(1).AsStringC());
       if (pNode)
         return pNode;
     } else if (bNewExprStyle) {
       CFX_WideString wsProcessedTarget = wsExpr;
       if (wsExpr.Left(4) == FX_WSTRC(L"som(") &&
           wsExpr.Right(1) == FX_WSTRC(L")")) {
@@ skipping 11 matching lines @@
     iSpliteIndex = iSpliteNextIndex;
   }
   return nullptr;
 }
 
 void SetLayoutGeneratedNodeFlag(CXFA_Node* pNode) {
   pNode->SetFlag(XFA_NodeFlag_LayoutGeneratedNode, false);
   pNode->ClearFlag(XFA_NodeFlag_UnusedNode);
 }
 
-FX_BOOL CheckContentAreaNotUsed(
+bool CheckContentAreaNotUsed(
     CXFA_ContainerLayoutItem* pPageAreaLayoutItem,
     CXFA_Node* pContentArea,
     CXFA_ContainerLayoutItem*& pContentAreaLayoutItem) {
   for (CXFA_ContainerLayoutItem* pLayoutItem =
            static_cast<CXFA_ContainerLayoutItem*>(
                pPageAreaLayoutItem->m_pFirstChild);
        pLayoutItem; pLayoutItem = static_cast<CXFA_ContainerLayoutItem*>(
                         pLayoutItem->m_pNextSibling)) {
     if (pLayoutItem->m_pFormNode == pContentArea) {
       if (!pLayoutItem->m_pFirstChild) {
         pContentAreaLayoutItem = pLayoutItem;
-        return TRUE;
+        return true;
       }
-      return FALSE;
+      return false;
     }
   }
-  return TRUE;
+  return true;
 }
 
 void SyncRemoveLayoutItem(CXFA_LayoutItem* pParentLayoutItem,
                           CXFA_FFNotify* pNotify,
                           CXFA_LayoutProcessor* pDocLayout) {
   CXFA_LayoutItem* pNextLayoutItem;
   CXFA_LayoutItem* pCurLayoutItem = pParentLayoutItem->m_pFirstChild;
   while (pCurLayoutItem) {
     pNextLayoutItem = pCurLayoutItem->m_pNextSibling;
     if (pCurLayoutItem->m_pFirstChild)
@@ skipping 24 matching lines @@
 CXFA_LayoutPageMgr::CXFA_LayoutPageMgr(CXFA_LayoutProcessor* pLayoutProcessor)
     : m_pLayoutProcessor(pLayoutProcessor),
       m_pTemplatePageSetRoot(nullptr),
       m_pPageSetLayoutItemRoot(nullptr),
       m_pPageSetCurRoot(nullptr),
       m_pCurrentContainerRecord(nullptr),
       m_pCurPageArea(nullptr),
       m_nAvailPages(0),
       m_nCurPageCount(0),
       m_ePageSetMode(XFA_ATTRIBUTEENUM_OrderedOccurrence),
-      m_bCreateOverFlowPage(FALSE) {}
+      m_bCreateOverFlowPage(false) {}
 
 CXFA_LayoutPageMgr::~CXFA_LayoutPageMgr() {
   ClearData();
   CXFA_LayoutItem* pLayoutItem = GetRootLayoutItem();
   CXFA_LayoutItem* pNextLayout = nullptr;
   for (; pLayoutItem; pLayoutItem = pNextLayout) {
     pNextLayout = pLayoutItem->m_pNextSibling;
     XFA_ReleaseLayoutItem(pLayoutItem);
   }
 }
 
-FX_BOOL CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) {
+bool CXFA_LayoutPageMgr::InitLayoutPage(CXFA_Node* pFormNode) {
   PrepareLayout();
   CXFA_Node* pTemplateNode = pFormNode->GetTemplateNode();
   if (!pTemplateNode)
-    return FALSE;
+    return false;
 
   m_pTemplatePageSetRoot = pTemplateNode->GetProperty(0, XFA_Element::PageSet);
   ASSERT(m_pTemplatePageSetRoot);
   if (m_pPageSetLayoutItemRoot) {
     m_pPageSetLayoutItemRoot->m_pParent = nullptr;
     m_pPageSetLayoutItemRoot->m_pFirstChild = nullptr;
     m_pPageSetLayoutItemRoot->m_pNextSibling = nullptr;
     m_pPageSetLayoutItemRoot->m_pFormNode = m_pTemplatePageSetRoot;
   } else {
     m_pPageSetLayoutItemRoot =
         new CXFA_ContainerLayoutItem(m_pTemplatePageSetRoot);
   }
   m_pPageSetCurRoot = m_pPageSetLayoutItemRoot;
   m_pTemplatePageSetRoot->SetUserData(XFA_LAYOUTITEMKEY,
                                       (void*)m_pPageSetLayoutItemRoot);
   XFA_ATTRIBUTEENUM eRelation =
       m_pTemplatePageSetRoot->GetEnum(XFA_ATTRIBUTE_Relation);
   if (eRelation != XFA_ATTRIBUTEENUM_Unknown)
     m_ePageSetMode = eRelation;
 
   InitPageSetMap();
   CXFA_Node* pPageArea = nullptr;
   int32_t iCount = 0;
   for (pPageArea = m_pTemplatePageSetRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
        pPageArea;
        pPageArea = pPageArea->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pPageArea->GetElementType() == XFA_Element::PageArea) {
       iCount++;
       if (pPageArea->GetFirstChildByClass(XFA_Element::ContentArea))
-        return TRUE;
+        return true;
     }
   }
   if (iCount > 0)
-    return FALSE;
+    return false;
 
   CXFA_Document* pDocument = pTemplateNode->GetDocument();
   pPageArea = m_pTemplatePageSetRoot->GetChild(0, XFA_Element::PageArea);
   if (!pPageArea) {
     pPageArea = pDocument->CreateNode(m_pTemplatePageSetRoot->GetPacketID(),
                                       XFA_Element::PageArea);
     if (!pPageArea)
-      return FALSE;
+      return false;
 
     m_pTemplatePageSetRoot->InsertChild(pPageArea, nullptr);
     pPageArea->SetFlag(XFA_NodeFlag_Initialized, true);
   }
   CXFA_Node* pContentArea = pPageArea->GetChild(0, XFA_Element::ContentArea);
   if (!pContentArea) {
     pContentArea = pDocument->CreateNode(pPageArea->GetPacketID(),
                                          XFA_Element::ContentArea);
     if (!pContentArea)
-      return FALSE;
+      return false;
 
     pPageArea->InsertChild(pContentArea, nullptr);
     pContentArea->SetFlag(XFA_NodeFlag_Initialized, true);
     pContentArea->SetMeasure(XFA_ATTRIBUTE_X,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_Y,
                              CXFA_Measurement(0.25f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_W,
                              CXFA_Measurement(8.0f, XFA_UNIT_In));
     pContentArea->SetMeasure(XFA_ATTRIBUTE_H,
                              CXFA_Measurement(10.5f, XFA_UNIT_In));
   }
   CXFA_Node* pMedium = pPageArea->GetChild(0, XFA_Element::Medium);
   if (!pMedium) {
     pMedium =
         pDocument->CreateNode(pPageArea->GetPacketID(), XFA_Element::Medium);
     if (!pContentArea)
-      return FALSE;
+      return false;
 
     pPageArea->InsertChild(pMedium, nullptr);
     pMedium->SetFlag(XFA_NodeFlag_Initialized, true);
     pMedium->SetMeasure(XFA_ATTRIBUTE_Short,
                         CXFA_Measurement(8.5f, XFA_UNIT_In));
     pMedium->SetMeasure(XFA_ATTRIBUTE_Long,
                         CXFA_Measurement(11.0f, XFA_UNIT_In));
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) {
-  FX_BOOL bProBreakBefore = FALSE;
+bool CXFA_LayoutPageMgr::PrepareFirstPage(CXFA_Node* pRootSubform) {
+  bool bProBreakBefore = false;
   CXFA_Node* pBreakBeforeNode = nullptr;
   while (pRootSubform) {
     for (CXFA_Node* pBreakNode =
              pRootSubform->GetNodeItem(XFA_NODEITEM_FirstChild);
          pBreakNode;
          pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
       XFA_Element eType = pBreakNode->GetElementType();
       if (eType == XFA_Element::BreakBefore ||
           (eType == XFA_Element::Break &&
            pBreakNode->GetEnum(XFA_ATTRIBUTE_Before) !=
                XFA_ATTRIBUTEENUM_Auto)) {
-        bProBreakBefore = TRUE;
+        bProBreakBefore = true;
         pBreakBeforeNode = pBreakNode;
         break;
       }
     }
     if (bProBreakBefore)
       break;
 
-    bProBreakBefore = TRUE;
+    bProBreakBefore = true;
     pRootSubform = pRootSubform->GetFirstChildByClass(XFA_Element::Subform);
     while (pRootSubform &&
            !XFA_ItemLayoutProcessor_IsTakingSpace(pRootSubform)) {
       pRootSubform =
           pRootSubform->GetNextSameClassSibling(XFA_Element::Subform);
     }
   }
   CXFA_Node *pLeader, *pTrailer;
   if (pBreakBeforeNode &&
-      ExecuteBreakBeforeOrAfter(pBreakBeforeNode, TRUE, pLeader, pTrailer)) {
+      ExecuteBreakBeforeOrAfter(pBreakBeforeNode, true, pLeader, pTrailer)) {
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
-    return TRUE;
+    return true;
   }
-  return AppendNewPage(TRUE);
+  return AppendNewPage(true);
 }
 
-FX_BOOL CXFA_LayoutPageMgr::AppendNewPage(FX_BOOL bFirstTemPage) {
+bool CXFA_LayoutPageMgr::AppendNewPage(bool bFirstTemPage) {
   if (m_pCurrentContainerRecord !=
       m_rgProposedContainerRecord.GetTailPosition()) {
-    return TRUE;
+    return true;
   }
   CXFA_Node* pPageNode = GetNextAvailPageArea(nullptr);
   if (!pPageNode)
-    return FALSE;
+    return false;
   if (bFirstTemPage && !m_pCurrentContainerRecord)
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetHeadPosition();
   return !bFirstTemPage || m_pCurrentContainerRecord;
 }
 
 void CXFA_LayoutPageMgr::RemoveLayoutRecord(CXFA_ContainerRecord* pNewRecord,
                                             CXFA_ContainerRecord* pPrevRecord) {
   if (!pNewRecord || !pPrevRecord)
     return;
   if (pNewRecord->pCurPageSet != pPrevRecord->pCurPageSet) {
@@ skipping 27 matching lines @@
     ReorderLayoutItemToTail(pNewRecord->pCurContentArea);
     return;
   }
 }
 
 void CXFA_LayoutPageMgr::SubmitContentItem(
     CXFA_ContentLayoutItem* pContentLayoutItem,
     XFA_ItemLayoutProcessorResult eStatus) {
   if (pContentLayoutItem) {
     GetCurrentContainerRecord()->pCurContentArea->AddChild(pContentLayoutItem);
-    m_bCreateOverFlowPage = FALSE;
+    m_bCreateOverFlowPage = false;
   }
 
   if (eStatus != XFA_ItemLayoutProcessorResult_Done) {
     if (eStatus == XFA_ItemLayoutProcessorResult_PageFullBreak &&
         m_pCurrentContainerRecord ==
             m_rgProposedContainerRecord.GetTailPosition()) {
       AppendNewPage();
     }
     m_pCurrentContainerRecord = m_rgProposedContainerRecord.GetTailPosition();
     m_pCurPageArea = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
@@ skipping 10 matching lines @@
       pLayoutItem->m_pFormNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
   if (fAvailHeight >= XFA_LAYOUT_FLOAT_PERCISION)
     return fAvailHeight;
   if (m_pCurrentContainerRecord ==
       m_rgProposedContainerRecord.GetHeadPosition()) {
     return 0.0f;
   }
   return XFA_LAYOUT_FLOAT_MAX;
 }
 
-FX_BOOL XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) {
+bool XFA_LayoutPageMgr_RunBreakTestScript(CXFA_Node* pTestScript) {
   CFX_WideString wsExpression;
   pTestScript->TryContent(wsExpression);
   if (wsExpression.IsEmpty())
-    return TRUE;
+    return true;
   return pTestScript->GetDocument()->GetNotify()->RunScript(
       pTestScript, pTestScript->GetNodeItem(XFA_NODEITEM_Parent,
                                             XFA_ObjectType::ContainerNode));
 }
 
 CXFA_ContainerRecord* CXFA_LayoutPageMgr::CreateContainerRecord(
     CXFA_Node* pPageNode,
-    FX_BOOL bCreateNew) {
+    bool bCreateNew) {
   CXFA_ContainerRecord* pNewRecord = new CXFA_ContainerRecord();
   if (m_pCurrentContainerRecord) {
     if (!IsPageSetRootOrderedOccurrence() || !pPageNode) {
       *pNewRecord = *GetCurrentContainerRecord();
       m_rgProposedContainerRecord.AddTail(pNewRecord);
       return pNewRecord;
     }
     CXFA_Node* pPageSet = pPageNode->GetNodeItem(XFA_NODEITEM_Parent);
     if (!bCreateNew) {
       if (pPageSet == m_pTemplatePageSetRoot) {
@@ skipping 119 matching lines @@
               continue;
             }
             nPageAreaCount++;
             pLastPageAreaLayoutItem = pPageAreaLayoutItem;
           }
           if (!pLastPageAreaLayoutItem)
             break;
 
           if (!FindPageAreaFromPageSet_SimplexDuplex(
                   pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr,
-                  TRUE, TRUE, nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only
+                  true, true, nPageAreaCount == 1 ? XFA_ATTRIBUTEENUM_Only
                                                   : XFA_ATTRIBUTEENUM_Last) &&
               (nPageAreaCount == 1 &&
                !FindPageAreaFromPageSet_SimplexDuplex(
                    pPageSetLayoutItem->m_pFormNode, nullptr, nullptr, nullptr,
-                   TRUE, TRUE, XFA_ATTRIBUTEENUM_Last))) {
+                   true, true, XFA_ATTRIBUTEENUM_Last))) {
             break;
           }
           CXFA_Node* pNode = m_pCurPageArea;
           XFA_ATTRIBUTEENUM eCurChoice =
               pNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
           if (eCurChoice == XFA_ATTRIBUTEENUM_Last) {
             XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any;
             pNode->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven);
             XFA_ATTRIBUTEENUM eLastChoice =
                 pLastPageAreaLayoutItem->m_pFormNode->GetEnum(
                     XFA_ATTRIBUTE_PagePosition);
             if (eLastChoice == XFA_ATTRIBUTEENUM_First &&
                 (ePageRelation == XFA_ATTRIBUTEENUM_SimplexPaginated ||
                  eOddOrEven != XFA_ATTRIBUTEENUM_Odd)) {
               CXFA_ContainerRecord* pRecord = CreateContainerRecord();
               AddPageAreaLayoutItem(pRecord, pNode);
               break;
             }
           }
-          FX_BOOL bUsable = TRUE;
+          bool bUsable = true;
           CFX_ArrayTemplate<FX_FLOAT> rgUsedHeights;
           for (CXFA_LayoutItem* pChildLayoutItem =
                    pLastPageAreaLayoutItem->m_pFirstChild;
                pChildLayoutItem;
                pChildLayoutItem = pChildLayoutItem->m_pNextSibling) {
             if (pChildLayoutItem->m_pFormNode->GetElementType() !=
                 XFA_Element::ContentArea) {
               continue;
             }
             FX_FLOAT fUsedHeight = 0;
@@ skipping 17 matching lines @@
                    pContentAreaNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
             if (pContentAreaNode->GetElementType() !=
                 XFA_Element::ContentArea) {
               continue;
             }
             iCurContentAreaIndex++;
             if (rgUsedHeights[iCurContentAreaIndex] >
                 pContentAreaNode->GetMeasure(XFA_ATTRIBUTE_H)
                         .ToUnit(XFA_UNIT_Pt) +
                     XFA_LAYOUT_FLOAT_PERCISION) {
-              bUsable = FALSE;
+              bUsable = false;
               break;
             }
           }
           if (bUsable) {
             CXFA_LayoutItem* pChildLayoutItem =
                 pLastPageAreaLayoutItem->m_pFirstChild;
             CXFA_Node* pContentAreaNode =
                 pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
             pLastPageAreaLayoutItem->m_pFormNode = pNode;
             while (pChildLayoutItem && pContentAreaNode) {
@@ skipping 33 matching lines @@
     return nullptr;
   return m_PageArray[index];
 }
 
 int32_t CXFA_LayoutPageMgr::GetPageIndex(
     const CXFA_ContainerLayoutItem* pPage) const {
   // FIXME: Find() method should take const.
   return m_PageArray.Find(const_cast<CXFA_ContainerLayoutItem*>(pPage));
 }
 
-FX_BOOL CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType,
-                                     XFA_ATTRIBUTEENUM eTargetType,
-                                     CXFA_Node* pTarget,
-                                     FX_BOOL bStartNew) {
-  FX_BOOL bRet = FALSE;
+bool CXFA_LayoutPageMgr::RunBreak(XFA_Element eBreakType,
+                                  XFA_ATTRIBUTEENUM eTargetType,
+                                  CXFA_Node* pTarget,
+                                  bool bStartNew) {
+  bool bRet = false;
   switch (eTargetType) {
     case XFA_ATTRIBUTEENUM_ContentArea:
       if (pTarget && pTarget->GetElementType() != XFA_Element::ContentArea)
         pTarget = nullptr;
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget !=
               GetCurrentContainerRecord()->pCurContentArea->m_pFormNode ||
           bStartNew) {
         CXFA_Node* pPageArea = nullptr;
         if (pTarget)
           pPageArea = pTarget->GetNodeItem(XFA_NODEITEM_Parent);
 
         pPageArea = GetNextAvailPageArea(pPageArea, pTarget);
         bRet = !!pPageArea;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageArea:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea)
         pTarget = nullptr;
       if (!pTarget || !m_pCurrentContainerRecord ||
           pTarget != GetCurrentContainerRecord()->pCurPageArea->m_pFormNode ||
           bStartNew) {
-        CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, nullptr, TRUE);
+        CXFA_Node* pPageArea = GetNextAvailPageArea(pTarget, nullptr, true);
         bRet = !!pPageArea;
       }
       break;
     case XFA_ATTRIBUTEENUM_PageOdd:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea)
         pTarget = nullptr;
       break;
     case XFA_ATTRIBUTEENUM_PageEven:
       if (pTarget && pTarget->GetElementType() != XFA_Element::PageArea)
         pTarget = nullptr;
       break;
     case XFA_ATTRIBUTEENUM_Auto:
     default:
       break;
   }
   return bRet;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter(
+bool CXFA_LayoutPageMgr::ExecuteBreakBeforeOrAfter(
     CXFA_Node* pCurNode,
-    FX_BOOL bBefore,
+    bool bBefore,
     CXFA_Node*& pBreakLeaderTemplate,
     CXFA_Node*& pBreakTrailerTemplate) {
   XFA_Element eType = pCurNode->GetElementType();
   switch (eType) {
     case XFA_Element::BreakBefore:
     case XFA_Element::BreakAfter: {
       CFX_WideStringC wsBreakLeader, wsBreakTrailer;
       CXFA_Node* pFormNode = pCurNode->GetNodeItem(
           XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
       CXFA_Node* pContainer = pFormNode->GetTemplateNode();
-      FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
+      bool bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
       CXFA_Node* pScript = pCurNode->GetFirstChildByClass(XFA_Element::Script);
       if (pScript && !XFA_LayoutPageMgr_RunBreakTestScript(pScript))
-        return FALSE;
+        return false;
 
       CFX_WideStringC wsTarget = pCurNode->GetCData(XFA_ATTRIBUTE_Target);
       CXFA_Node* pTarget =
-          ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
+          ResolveBreakTarget(m_pTemplatePageSetRoot, true, wsTarget);
       wsBreakTrailer = pCurNode->GetCData(XFA_ATTRIBUTE_Trailer);
       wsBreakLeader = pCurNode->GetCData(XFA_ATTRIBUTE_Leader);
       pBreakLeaderTemplate =
-          ResolveBreakTarget(pContainer, TRUE, wsBreakLeader);
+          ResolveBreakTarget(pContainer, true, wsBreakLeader);
       pBreakTrailerTemplate =
-          ResolveBreakTarget(pContainer, TRUE, wsBreakTrailer);
+          ResolveBreakTarget(pContainer, true, wsBreakTrailer);
       if (RunBreak(eType, pCurNode->GetEnum(XFA_ATTRIBUTE_TargetType), pTarget,
                    bStartNew)) {
-        return TRUE;
+        return true;
       }
       if (m_rgProposedContainerRecord.GetCount() > 0 &&
           m_pCurrentContainerRecord ==
               m_rgProposedContainerRecord.GetHeadPosition() &&
           eType == XFA_Element::BreakBefore) {
         CXFA_Node* pParentNode = pFormNode->GetNodeItem(
             XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
         if (!pParentNode ||
             pFormNode !=
                 pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild,
                                          XFA_ObjectType::ContainerNode)) {
           break;
         }
         pParentNode = pParentNode->GetNodeItem(XFA_NODEITEM_Parent);
         if (!pParentNode ||
             pParentNode->GetElementType() != XFA_Element::Form) {
           break;
         }
-        return TRUE;
+        return true;
       }
       break;
     }
     case XFA_Element::Break: {
-      FX_BOOL bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
+      bool bStartNew = pCurNode->GetInteger(XFA_ATTRIBUTE_StartNew) != 0;
       CFX_WideStringC wsTarget = pCurNode->GetCData(
           bBefore ? XFA_ATTRIBUTE_BeforeTarget : XFA_ATTRIBUTE_AfterTarget);
       CXFA_Node* pTarget =
-          ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsTarget);
+          ResolveBreakTarget(m_pTemplatePageSetRoot, true, wsTarget);
       if (RunBreak(bBefore ? XFA_Element::BreakBefore : XFA_Element::BreakAfter,
                    pCurNode->GetEnum(bBefore ? XFA_ATTRIBUTE_Before
                                              : XFA_ATTRIBUTE_After),
                    pTarget, bStartNew)) {
-        return TRUE;
+        return true;
       }
       break;
     }
     default:
       break;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter(
+bool CXFA_LayoutPageMgr::ProcessBreakBeforeOrAfter(
     CXFA_Node* pBreakNode,
-    FX_BOOL bBefore,
+    bool bBefore,
     CXFA_Node*& pBreakLeaderNode,
     CXFA_Node*& pBreakTrailerNode,
-    FX_BOOL& bCreatePage) {
+    bool& bCreatePage) {
   CXFA_Node* pLeaderTemplate = nullptr;
   CXFA_Node* pTrailerTemplate = nullptr;
   CXFA_Node* pFormNode = pBreakNode->GetNodeItem(XFA_NODEITEM_Parent,
                                                  XFA_ObjectType::ContainerNode);
   if (XFA_ItemLayoutProcessor_IsTakingSpace(pFormNode)) {
     bCreatePage = ExecuteBreakBeforeOrAfter(pBreakNode, bBefore,
                                             pLeaderTemplate, pTrailerTemplate);
     CXFA_Document* pDocument = pBreakNode->GetDocument();
     CXFA_Node* pDataScope = nullptr;
     pFormNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent,
                                        XFA_ObjectType::ContainerNode);
     if (pLeaderTemplate) {
       if (!pDataScope)
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
       pBreakLeaderNode = pDocument->DataMerge_CopyContainer(
-          pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE);
+          pLeaderTemplate, pFormNode, pDataScope, true, true, true);
       pDocument->DataMerge_UpdateBindingRelations(pBreakLeaderNode);
       SetLayoutGeneratedNodeFlag(pBreakLeaderNode);
     }
     if (pTrailerTemplate) {
       if (!pDataScope)
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
       pBreakTrailerNode = pDocument->DataMerge_CopyContainer(
-          pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE);
+          pTrailerTemplate, pFormNode, pDataScope, true, true, true);
       pDocument->DataMerge_UpdateBindingRelations(pBreakTrailerNode);
       SetLayoutGeneratedNodeFlag(pBreakTrailerNode);
     }
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer(
+bool CXFA_LayoutPageMgr::ProcessBookendLeaderOrTrailer(
     CXFA_Node* pBookendNode,
-    FX_BOOL bLeader,
+    bool bLeader,
     CXFA_Node*& pBookendAppendNode) {
   CXFA_Node* pLeaderTemplate = nullptr;
   CXFA_Node* pFormNode = pBookendNode->GetNodeItem(
       XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode);
   if (ResolveBookendLeaderOrTrailer(pBookendNode, bLeader, pLeaderTemplate)) {
     CXFA_Document* pDocument = pBookendNode->GetDocument();
     CXFA_Node* pDataScope = nullptr;
     if (pLeaderTemplate) {
       if (!pDataScope)
         pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
       pBookendAppendNode = pDocument->DataMerge_CopyContainer(
-          pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE);
+          pLeaderTemplate, pFormNode, pDataScope, true, true, true);
       pDocument->DataMerge_UpdateBindingRelations(pBookendAppendNode);
       SetLayoutGeneratedNodeFlag(pBookendAppendNode);
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
 CXFA_Node* CXFA_LayoutPageMgr::BreakOverflow(CXFA_Node* pOverflowNode,
                                              CXFA_Node*& pLeaderTemplate,
                                              CXFA_Node*& pTrailerTemplate,
-                                             FX_BOOL bCreatePage) {
+                                             bool bCreatePage) {
   CXFA_Node* pContainer =
       pOverflowNode
           ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
   if (pOverflowNode->GetElementType() == XFA_Element::Break) {
     CFX_WideStringC wsOverflowLeader;
     CFX_WideStringC wsOverflowTarget;
     CFX_WideStringC wsOverflowTrailer;
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowLeader, wsOverflowLeader);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTrailer, wsOverflowTrailer);
     pOverflowNode->TryCData(XFA_ATTRIBUTE_OverflowTarget, wsOverflowTarget);
     if (!wsOverflowLeader.IsEmpty() || !wsOverflowTrailer.IsEmpty() ||
         !wsOverflowTarget.IsEmpty()) {
       if (!wsOverflowTarget.IsEmpty() && bCreatePage &&
           !m_bCreateOverFlowPage) {
         CXFA_Node* pTarget =
-            ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
+            ResolveBreakTarget(m_pTemplatePageSetRoot, true, wsOverflowTarget);
         if (pTarget) {
-          m_bCreateOverFlowPage = TRUE;
+          m_bCreateOverFlowPage = true;
           switch (pTarget->GetElementType()) {
             case XFA_Element::PageArea:
               RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea,
-                       pTarget, TRUE);
+                       pTarget, true);
               break;
             case XFA_Element::ContentArea:
               RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
-                       pTarget, TRUE);
+                       pTarget, true);
               break;
             default:
               break;
           }
         }
       }
       if (!bCreatePage) {
         pLeaderTemplate =
-            ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
+            ResolveBreakTarget(pContainer, true, wsOverflowLeader);
         pTrailerTemplate =
-            ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
+            ResolveBreakTarget(pContainer, true, wsOverflowTrailer);
       }
       return pOverflowNode;
     }
     return nullptr;
   }
 
   if (pOverflowNode->GetElementType() != XFA_Element::Overflow)
     return nullptr;
 
   CFX_WideStringC wsOverflowLeader;
   CFX_WideStringC wsOverflowTrailer;
   CFX_WideStringC wsOverflowTarget;
   pOverflowNode->TryCData(XFA_ATTRIBUTE_Leader, wsOverflowLeader);
   pOverflowNode->TryCData(XFA_ATTRIBUTE_Trailer, wsOverflowTrailer);
   pOverflowNode->TryCData(XFA_ATTRIBUTE_Target, wsOverflowTarget);
   if (!wsOverflowTarget.IsEmpty() && bCreatePage && !m_bCreateOverFlowPage) {
     CXFA_Node* pTarget =
-        ResolveBreakTarget(m_pTemplatePageSetRoot, TRUE, wsOverflowTarget);
+        ResolveBreakTarget(m_pTemplatePageSetRoot, true, wsOverflowTarget);
     if (pTarget) {
-      m_bCreateOverFlowPage = TRUE;
+      m_bCreateOverFlowPage = true;
       switch (pTarget->GetElementType()) {
         case XFA_Element::PageArea:
           RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_PageArea, pTarget,
-                   TRUE);
+                   true);
           break;
         case XFA_Element::ContentArea:
           RunBreak(XFA_Element::Overflow, XFA_ATTRIBUTEENUM_ContentArea,
-                   pTarget, TRUE);
+                   pTarget, true);
           break;
         default:
           break;
       }
     }
   }
   if (!bCreatePage) {
-    pLeaderTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowLeader);
-    pTrailerTemplate = ResolveBreakTarget(pContainer, TRUE, wsOverflowTrailer);
+    pLeaderTemplate = ResolveBreakTarget(pContainer, true, wsOverflowLeader);
+    pTrailerTemplate = ResolveBreakTarget(pContainer, true, wsOverflowTrailer);
   }
   return pOverflowNode;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
-                                            CXFA_Node*& pLeaderNode,
-                                            CXFA_Node*& pTrailerNode,
-                                            FX_BOOL bDataMerge,
-                                            FX_BOOL bCreatePage) {
+bool CXFA_LayoutPageMgr::ProcessOverflow(CXFA_Node* pFormNode,
+                                         CXFA_Node*& pLeaderNode,
+                                         CXFA_Node*& pTrailerNode,
+                                         bool bDataMerge,
+                                         bool bCreatePage) {
   if (!pFormNode)
-    return FALSE;
+    return false;
 
   CXFA_Node* pLeaderTemplate = nullptr;
   CXFA_Node* pTrailerTemplate = nullptr;
-  FX_BOOL bIsOverflowNode = FALSE;
+  bool bIsOverflowNode = false;
   if (pFormNode->GetElementType() == XFA_Element::Overflow ||
       pFormNode->GetElementType() == XFA_Element::Break) {
-    bIsOverflowNode = TRUE;
+    bIsOverflowNode = true;
   }
   for (CXFA_Node* pCurNode =
            bIsOverflowNode ? pFormNode
                            : pFormNode->GetNodeItem(XFA_NODEITEM_FirstChild);
        pCurNode; pCurNode = pCurNode->GetNodeItem((XFA_NODEITEM_NextSibling))) {
     if (BreakOverflow(pCurNode, pLeaderTemplate, pTrailerTemplate,
                       bCreatePage)) {
       if (bIsOverflowNode)
         pFormNode = pCurNode->GetNodeItem(XFA_NODEITEM_Parent);
 
       CXFA_Document* pDocument = pCurNode->GetDocument();
       CXFA_Node* pDataScope = nullptr;
       if (pLeaderTemplate) {
         if (!pDataScope)
           pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
         pLeaderNode = pDocument->DataMerge_CopyContainer(
-            pLeaderTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE);
+            pLeaderTemplate, pFormNode, pDataScope, true, true, true);
         pDocument->DataMerge_UpdateBindingRelations(pLeaderNode);
         SetLayoutGeneratedNodeFlag(pLeaderNode);
       }
       if (pTrailerTemplate) {
         if (!pDataScope)
           pDataScope = XFA_DataMerge_FindDataScope(pFormNode);
 
         pTrailerNode = pDocument->DataMerge_CopyContainer(
-            pTrailerTemplate, pFormNode, pDataScope, TRUE, TRUE, TRUE);
+            pTrailerTemplate, pFormNode, pDataScope, true, true, true);
         pDocument->DataMerge_UpdateBindingRelations(pTrailerNode);
         SetLayoutGeneratedNodeFlag(pTrailerNode);
       }
-      return TRUE;
+      return true;
     }
     if (bIsOverflowNode) {
       break;
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
+bool CXFA_LayoutPageMgr::ResolveBookendLeaderOrTrailer(
     CXFA_Node* pBookendNode,
-    FX_BOOL bLeader,
+    bool bLeader,
     CXFA_Node*& pBookendAppendTemplate) {
   CFX_WideStringC wsBookendLeader;
   CXFA_Node* pContainer =
       pBookendNode
           ->GetNodeItem(XFA_NODEITEM_Parent, XFA_ObjectType::ContainerNode)
           ->GetTemplateNode();
   if (pBookendNode->GetElementType() == XFA_Element::Break) {
     pBookendNode->TryCData(
         bLeader ? XFA_ATTRIBUTE_BookendLeader : XFA_ATTRIBUTE_BookendTrailer,
         wsBookendLeader);
     if (!wsBookendLeader.IsEmpty()) {
       pBookendAppendTemplate =
-          ResolveBreakTarget(pContainer, FALSE, wsBookendLeader);
-      return TRUE;
+          ResolveBreakTarget(pContainer, false, wsBookendLeader);
+      return true;
     }
-    return FALSE;
+    return false;
   } else if (pBookendNode->GetElementType() == XFA_Element::Bookend) {
     pBookendNode->TryCData(
         bLeader ? XFA_ATTRIBUTE_Leader : XFA_ATTRIBUTE_Trailer,
         wsBookendLeader);
     pBookendAppendTemplate =
-        ResolveBreakTarget(pContainer, TRUE, wsBookendLeader);
-    return TRUE;
+        ResolveBreakTarget(pContainer, true, wsBookendLeader);
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet(
-    CXFA_Node* pPageSet,
-    CXFA_Node* pStartChild,
-    CXFA_Node* pTargetPageArea,
-    CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
+bool CXFA_LayoutPageMgr::FindPageAreaFromPageSet(CXFA_Node* pPageSet,
+                                                 CXFA_Node* pStartChild,
+                                                 CXFA_Node* pTargetPageArea,
+                                                 CXFA_Node* pTargetContentArea,
+                                                 bool bNewPage,
+                                                 bool bQuery) {
   if (!pPageSet && !pStartChild)
-    return FALSE;
+    return false;
 
   if (IsPageSetRootOrderedOccurrence()) {
     return FindPageAreaFromPageSet_Ordered(pPageSet, pStartChild,
                                            pTargetPageArea, pTargetContentArea,
                                            bNewPage, bQuery);
   }
   XFA_ATTRIBUTEENUM ePreferredPosition = m_pCurrentContainerRecord
                                              ? XFA_ATTRIBUTEENUM_Rest
                                              : XFA_ATTRIBUTEENUM_First;
   return FindPageAreaFromPageSet_SimplexDuplex(
       pPageSet, pStartChild, pTargetPageArea, pTargetContentArea, bNewPage,
       bQuery, ePreferredPosition);
 }
 
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered(
+bool CXFA_LayoutPageMgr::FindPageAreaFromPageSet_Ordered(
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
+    bool bNewPage,
+    bool bQuery) {
   int32_t iPageSetCount = 0;
   if (!pStartChild && !bQuery) {
     m_pPageSetMap.Lookup(pPageSet, iPageSetCount);
     int32_t iMax = -1;
     CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur);
     if (pOccurNode)
-      pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
+      pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, false);
     if (iMax >= 0 && iMax <= iPageSetCount)
-      return FALSE;
+      return false;
   }
 
-  FX_BOOL bRes = FALSE;
+  bool bRes = false;
   CXFA_Node* pCurrentNode =
       pStartChild ? pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling)
                   : pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea) {
       if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) {
         if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) {
           if (pTargetPageArea == pCurrentNode) {
-            CreateMinPageRecord(pCurrentNode, TRUE);
+            CreateMinPageRecord(pCurrentNode, true);
             pTargetPageArea = nullptr;
           }
           continue;
         }
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
               CreateContainerRecord(pCurrentNode, !pStartChild);
           AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
           if (!pTargetContentArea) {
             pTargetContentArea =
                 pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_pCurPageArea = pCurrentNode;
         m_nCurPageCount = 1;
-        bRes = TRUE;
+        bRes = true;
         break;
       }
       if (!bQuery)
-        CreateMinPageRecord(pCurrentNode, FALSE);
+        CreateMinPageRecord(pCurrentNode, false);
     } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) {
       if (FindPageAreaFromPageSet_Ordered(pCurrentNode, nullptr,
                                           pTargetPageArea, pTargetContentArea,
                                           bNewPage, bQuery)) {
-        bRes = TRUE;
+        bRes = true;
         break;
       }
       if (!bQuery)
-        CreateMinPageSetRecord(pCurrentNode, TRUE);
+        CreateMinPageSetRecord(pCurrentNode, true);
     }
   }
   if (!pStartChild && bRes && !bQuery)
     m_pPageSetMap.SetAt(pPageSet, ++iPageSetCount);
   return bRes;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex(
+bool CXFA_LayoutPageMgr::FindPageAreaFromPageSet_SimplexDuplex(
     CXFA_Node* pPageSet,
     CXFA_Node* pStartChild,
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery,
+    bool bNewPage,
+    bool bQuery,
     XFA_ATTRIBUTEENUM ePreferredPosition) {
   const XFA_ATTRIBUTEENUM eFallbackPosition = XFA_ATTRIBUTEENUM_Any;
   CXFA_Node* pPreferredPageArea = nullptr;
   CXFA_Node* pFallbackPageArea = nullptr;
   CXFA_Node* pCurrentNode = nullptr;
   if (!pStartChild || pStartChild->GetElementType() == XFA_Element::PageArea)
     pCurrentNode = pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
   else
     pCurrentNode = pStartChild->GetNodeItem(XFA_NODEITEM_NextSibling);
 
   for (; pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea) {
-      if (!MatchPageAreaOddOrEven(pCurrentNode, FALSE))
+      if (!MatchPageAreaOddOrEven(pCurrentNode, false))
         continue;
 
       XFA_ATTRIBUTEENUM eCurPagePosition =
           pCurrentNode->GetEnum(XFA_ATTRIBUTE_PagePosition);
       if (ePreferredPosition == XFA_ATTRIBUTEENUM_Last) {
         if (eCurPagePosition != ePreferredPosition)
           continue;
         if (m_ePageSetMode == XFA_ATTRIBUTEENUM_SimplexPaginated ||
             pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
                 XFA_ATTRIBUTEENUM_Any) {
           pPreferredPageArea = pCurrentNode;
           break;
         }
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
         AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
                                                  XFA_Element::ContentArea));
         pPreferredPageArea = pCurrentNode;
-        return FALSE;
+        return false;
       }
       if (ePreferredPosition == XFA_ATTRIBUTEENUM_Only) {
         if (eCurPagePosition != ePreferredPosition)
           continue;
         if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated ||
             pCurrentNode->GetEnum(XFA_ATTRIBUTE_OddOrEven) ==
                 XFA_ATTRIBUTEENUM_Any) {
           pPreferredPageArea = pCurrentNode;
           break;
         }
-        return FALSE;
+        return false;
       }
       if ((pTargetPageArea == pCurrentNode || !pTargetPageArea)) {
         if (!pCurrentNode->GetFirstChildByClass(XFA_Element::ContentArea)) {
           if (pTargetPageArea == pCurrentNode) {
             CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
             AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
             pTargetPageArea = nullptr;
           }
           continue;
         }
         if ((ePreferredPosition == XFA_ATTRIBUTEENUM_Rest &&
              eCurPagePosition == XFA_ATTRIBUTEENUM_Any) ||
             eCurPagePosition == ePreferredPosition) {
           pPreferredPageArea = pCurrentNode;
           break;
         } else if (eCurPagePosition == eFallbackPosition &&
                    !pFallbackPageArea) {
           pFallbackPageArea = pCurrentNode;
         }
       } else if (pTargetPageArea &&
-                 !MatchPageAreaOddOrEven(pTargetPageArea, FALSE)) {
+                 !MatchPageAreaOddOrEven(pTargetPageArea, false)) {
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         AddPageAreaLayoutItem(pNewRecord, pCurrentNode);
         AddContentAreaLayoutItem(pNewRecord, pCurrentNode->GetFirstChildByClass(
                                                  XFA_Element::ContentArea));
       }
     } else if (pCurrentNode->GetElementType() == XFA_Element::PageSet) {
       if (FindPageAreaFromPageSet_SimplexDuplex(
               pCurrentNode, nullptr, pTargetPageArea, pTargetContentArea,
               bNewPage, bQuery, ePreferredPosition)) {
         break;
       }
     }
   }
 
   CXFA_Node* pCurPageArea = nullptr;
   if (pPreferredPageArea)
     pCurPageArea = pPreferredPageArea;
   else if (pFallbackPageArea)
     pCurPageArea = pFallbackPageArea;
 
   if (!pCurPageArea)
-    return FALSE;
+    return false;
 
   if (!bQuery) {
     CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
     AddPageAreaLayoutItem(pNewRecord, pCurPageArea);
     if (!pTargetContentArea) {
       pTargetContentArea =
           pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     }
     AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
   }
   m_pCurPageArea = pCurPageArea;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea,
-                                                   FX_BOOL bLastMatch) {
+bool CXFA_LayoutPageMgr::MatchPageAreaOddOrEven(CXFA_Node* pPageArea,
+                                                bool bLastMatch) {
   if (m_ePageSetMode != XFA_ATTRIBUTEENUM_DuplexPaginated)
-    return TRUE;
+    return true;
 
   XFA_ATTRIBUTEENUM eOddOrEven = XFA_ATTRIBUTEENUM_Any;
   pPageArea->TryEnum(XFA_ATTRIBUTE_OddOrEven, eOddOrEven);
   if (eOddOrEven != XFA_ATTRIBUTEENUM_Any) {
     int32_t iPageCount = GetPageCount();
     if (bLastMatch) {
       return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 1
                                                  : iPageCount % 2 == 0;
     }
     return eOddOrEven == XFA_ATTRIBUTEENUM_Odd ? iPageCount % 2 == 0
                                                : iPageCount % 2 == 1;
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_Node* CXFA_LayoutPageMgr::GetNextAvailPageArea(
     CXFA_Node* pTargetPageArea,
     CXFA_Node* pTargetContentArea,
-    FX_BOOL bNewPage,
-    FX_BOOL bQuery) {
+    bool bNewPage,
+    bool bQuery) {
   if (!m_pCurPageArea) {
     FindPageAreaFromPageSet(m_pTemplatePageSetRoot, nullptr, pTargetPageArea,
                             pTargetContentArea, bNewPage, bQuery);
     ASSERT(m_pCurPageArea);
     return m_pCurPageArea;
   }
 
   if (!pTargetPageArea || pTargetPageArea == m_pCurPageArea) {
     if (!bNewPage && GetNextContentArea(pTargetContentArea))
       return m_pCurPageArea;
 
     if (IsPageSetRootOrderedOccurrence()) {
       int32_t iMax = -1;
       CXFA_Node* pOccurNode =
           m_pCurPageArea->GetFirstChildByClass(XFA_Element::Occur);
       if (pOccurNode)
-        pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE);
+        pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, false);
       if ((iMax < 0 || m_nCurPageCount < iMax)) {
         if (!bQuery) {
           CXFA_ContainerRecord* pNewRecord =
               CreateContainerRecord(m_pCurPageArea);
           AddPageAreaLayoutItem(pNewRecord, m_pCurPageArea);
           if (!pTargetContentArea) {
             pTargetContentArea =
                 m_pCurPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
           }
           AddContentAreaLayoutItem(pNewRecord, pTargetContentArea);
         }
         m_nCurPageCount++;
         return m_pCurPageArea;
       }
     }
   }
 
   if (!bQuery && IsPageSetRootOrderedOccurrence())
-    CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
+    CreateMinPageRecord(m_pCurPageArea, false, true);
   if (FindPageAreaFromPageSet(m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent),
                               m_pCurPageArea, pTargetPageArea,
                               pTargetContentArea, bNewPage, bQuery)) {
     return m_pCurPageArea;
   }
 
   CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
-  while (TRUE) {
+  while (true) {
     if (FindPageAreaFromPageSet(pPageSet, nullptr, pTargetPageArea,
                                 pTargetContentArea, bNewPage, bQuery)) {
       return m_pCurPageArea;
     }
     if (!bQuery && IsPageSetRootOrderedOccurrence())
       CreateMinPageSetRecord(pPageSet);
     if (FindPageAreaFromPageSet(nullptr, pPageSet, pTargetPageArea,
                                 pTargetContentArea, bNewPage, bQuery)) {
       return m_pCurPageArea;
     }
     if (pPageSet == m_pTemplatePageSetRoot)
       break;
 
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
   return nullptr;
 }
 
-FX_BOOL CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) {
+bool CXFA_LayoutPageMgr::GetNextContentArea(CXFA_Node* pContentArea) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
   if (!pContentArea) {
     pContentArea =
         pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
     if (!pContentArea)
-      return FALSE;
+      return false;
   } else {
     if (pContentArea->GetNodeItem(XFA_NODEITEM_Parent) != m_pCurPageArea)
-      return FALSE;
+      return false;
 
     CXFA_ContainerLayoutItem* pContentAreaLayout = nullptr;
     if (!CheckContentAreaNotUsed(GetCurrentContainerRecord()->pCurPageArea,
                                  pContentArea, pContentAreaLayout)) {
-      return FALSE;
+      return false;
     }
     if (pContentAreaLayout) {
       if (pContentAreaLayout->m_pFormNode != pCurContentNode) {
         CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
         pNewRecord->pCurContentArea = pContentAreaLayout;
-        return TRUE;
+        return true;
       }
-      return FALSE;
+      return false;
     }
   }
 
   CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
   AddContentAreaLayoutItem(pNewRecord, pContentArea);
-  return TRUE;
+  return true;
 }
 
 void CXFA_LayoutPageMgr::InitPageSetMap() {
   if (!IsPageSetRootOrderedOccurrence())
     return;
 
   CXFA_NodeIterator sIterator(m_pTemplatePageSetRoot);
   for (CXFA_Node* pPageSetNode = sIterator.GetCurrent(); pPageSetNode;
        pPageSetNode = sIterator.MoveToNext()) {
     if (pPageSetNode->GetElementType() == XFA_Element::PageSet) {
       XFA_ATTRIBUTEENUM eRelation =
           pPageSetNode->GetEnum(XFA_ATTRIBUTE_Relation);
       if (eRelation == XFA_ATTRIBUTEENUM_OrderedOccurrence)
         m_pPageSetMap.SetAt(pPageSetNode, 0);
     }
   }
 }
 
 int32_t CXFA_LayoutPageMgr::CreateMinPageRecord(CXFA_Node* pPageArea,
-                                                FX_BOOL bTargetPageArea,
-                                                FX_BOOL bCreateLast) {
+                                                bool bTargetPageArea,
+                                                bool bCreateLast) {
   if (!pPageArea)
     return 0;
 
   CXFA_Node* pOccurNode = pPageArea->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMin = 0;
-  if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) ||
+  if ((pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, false)) ||
       bTargetPageArea) {
     CXFA_Node* pContentArea =
         pPageArea->GetFirstChildByClass(XFA_Element::ContentArea);
     if (iMin < 1 && bTargetPageArea && !pContentArea)
       iMin = 1;
 
     int32_t i = 0;
     if (bCreateLast)
       i = m_nCurPageCount;
 
     for (; i < iMin; i++) {
       CXFA_ContainerRecord* pNewRecord = CreateContainerRecord();
       AddPageAreaLayoutItem(pNewRecord, pPageArea);
       AddContentAreaLayoutItem(pNewRecord, pContentArea);
     }
   }
   return iMin;
 }
 
 void CXFA_LayoutPageMgr::CreateMinPageSetRecord(CXFA_Node* pPageSet,
-                                                FX_BOOL bCreateAll) {
+                                                bool bCreateAll) {
   if (!pPageSet)
     return;
 
   int32_t iCurSetCount = 0;
   if (!m_pPageSetMap.Lookup(pPageSet, iCurSetCount))
     return;
   if (bCreateAll)
     iCurSetCount = 0;
 
   CXFA_Node* pOccurNode = pPageSet->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMin = 0;
-  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, FALSE)) {
+  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Min, iMin, false)) {
     if (iCurSetCount < iMin) {
       for (int32_t i = 0; i < iMin - iCurSetCount; i++) {
         for (CXFA_Node* pCurrentPageNode =
                  pPageSet->GetNodeItem(XFA_NODEITEM_FirstChild);
              pCurrentPageNode; pCurrentPageNode = pCurrentPageNode->GetNodeItem(
                                    XFA_NODEITEM_NextSibling)) {
           if (pCurrentPageNode->GetElementType() == XFA_Element::PageArea) {
-            CreateMinPageRecord(pCurrentPageNode, FALSE);
+            CreateMinPageRecord(pCurrentPageNode, false);
           } else if (pCurrentPageNode->GetElementType() ==
                      XFA_Element::PageSet) {
-            CreateMinPageSetRecord(pCurrentPageNode, TRUE);
+            CreateMinPageSetRecord(pCurrentPageNode, true);
           }
         }
       }
       m_pPageSetMap.SetAt(pPageSet, iMin);
     }
   }
 }
 
 void CXFA_LayoutPageMgr::CreateNextMinRecord(CXFA_Node* pRecordNode) {
   if (!pRecordNode)
     return;
 
   for (CXFA_Node* pCurrentNode =
            pRecordNode->GetNodeItem(XFA_NODEITEM_NextSibling);
        pCurrentNode;
        pCurrentNode = pCurrentNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pCurrentNode->GetElementType() == XFA_Element::PageArea)
-      CreateMinPageRecord(pCurrentNode, FALSE);
+      CreateMinPageRecord(pCurrentNode, false);
     else if (pCurrentNode->GetElementType() == XFA_Element::PageSet)
-      CreateMinPageSetRecord(pCurrentNode, TRUE);
+      CreateMinPageSetRecord(pCurrentNode, true);
   }
 }
 
 void CXFA_LayoutPageMgr::ProcessLastPageSet() {
-  CreateMinPageRecord(m_pCurPageArea, FALSE, TRUE);
+  CreateMinPageRecord(m_pCurPageArea, false, true);
   CreateNextMinRecord(m_pCurPageArea);
   CXFA_Node* pPageSet = m_pCurPageArea->GetNodeItem(XFA_NODEITEM_Parent);
-  while (TRUE) {
+  while (true) {
     CreateMinPageSetRecord(pPageSet);
     if (pPageSet == m_pTemplatePageSetRoot)
       break;
 
     CreateNextMinRecord(pPageSet);
     pPageSet = pPageSet->GetNodeItem(XFA_NODEITEM_Parent);
   }
 }
 
-FX_BOOL CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) {
+bool CXFA_LayoutPageMgr::GetNextAvailContentHeight(FX_FLOAT fChildHeight) {
   CXFA_Node* pCurContentNode =
       GetCurrentContainerRecord()->pCurContentArea->m_pFormNode;
   if (!pCurContentNode)
-    return FALSE;
+    return false;
 
   pCurContentNode =
       pCurContentNode->GetNextSameClassSibling(XFA_Element::ContentArea);
   if (pCurContentNode) {
     FX_FLOAT fNextContentHeight =
         pCurContentNode->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
     return fNextContentHeight > fChildHeight;
   }
 
   CXFA_Node* pPageNode = GetCurrentContainerRecord()->pCurPageArea->m_pFormNode;
   CXFA_Node* pOccurNode = pPageNode->GetFirstChildByClass(XFA_Element::Occur);
   int32_t iMax = 0;
-  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, FALSE)) {
+  if (pOccurNode && pOccurNode->TryInteger(XFA_ATTRIBUTE_Max, iMax, false)) {
     if (m_nCurPageCount == iMax) {
       CXFA_Node* pSrcPage = m_pCurPageArea;
       int32_t nSrcPageCount = m_nCurPageCount;
       FX_POSITION psSrcRecord = m_rgProposedContainerRecord.GetTailPosition();
       CXFA_Node* pNextPage =
-          GetNextAvailPageArea(nullptr, nullptr, FALSE, TRUE);
+          GetNextAvailPageArea(nullptr, nullptr, false, true);
       m_pCurPageArea = pSrcPage;
       m_nCurPageCount = nSrcPageCount;
       CXFA_ContainerRecord* pPrevRecord = static_cast<CXFA_ContainerRecord*>(
           m_rgProposedContainerRecord.GetNext(psSrcRecord));
       while (psSrcRecord) {
         FX_POSITION psSaveRecord = psSrcRecord;
         CXFA_ContainerRecord* pInsertRecord =
             static_cast<CXFA_ContainerRecord*>(
                 m_rgProposedContainerRecord.GetNext(psSrcRecord));
         RemoveLayoutRecord(pInsertRecord, pPrevRecord);
         delete pInsertRecord;
         m_rgProposedContainerRecord.RemoveAt(psSaveRecord);
       }
       if (pNextPage) {
         CXFA_Node* pContentArea =
             pNextPage->GetFirstChildByClass(XFA_Element::ContentArea);
         if (pContentArea) {
           FX_FLOAT fNextContentHeight =
               pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
           if (fNextContentHeight > fChildHeight)
-            return TRUE;
+            return true;
         }
       }
-      return FALSE;
+      return false;
     }
   }
 
   CXFA_Node* pContentArea =
       pPageNode->GetFirstChildByClass(XFA_Element::ContentArea);
   FX_FLOAT fNextContentHeight =
       pContentArea->GetMeasure(XFA_ATTRIBUTE_H).ToUnit(XFA_UNIT_Pt);
   if (fNextContentHeight < XFA_LAYOUT_FLOAT_PERCISION)
-    return TRUE;
+    return true;
   if (fNextContentHeight > fChildHeight)
-    return TRUE;
-  return FALSE;
+    return true;
+  return false;
 }
 
 void CXFA_LayoutPageMgr::ClearData() {
   ClearRecordList();
 }
 
 void CXFA_LayoutPageMgr::ClearRecordList() {
   if (!m_pTemplatePageSetRoot)
     return;
   if (m_rgProposedContainerRecord.GetCount() > 0) {
     FX_POSITION sPos;
     sPos = m_rgProposedContainerRecord.GetHeadPosition();
     while (sPos) {
       CXFA_ContainerRecord* pRecord = static_cast<CXFA_ContainerRecord*>(
           m_rgProposedContainerRecord.GetNext(sPos));
       delete pRecord;
     }
     m_rgProposedContainerRecord.RemoveAll();
   }
   m_pCurrentContainerRecord = nullptr;
   m_pCurPageArea = nullptr;
   m_nCurPageCount = 0;
-  m_bCreateOverFlowPage = FALSE;
+  m_bCreateOverFlowPage = false;
   m_pPageSetMap.RemoveAll();
 }
 
 CXFA_LayoutItem* CXFA_LayoutPageMgr::FindOrCreateLayoutItem(
     CXFA_Node* pFormNode) {
   return pFormNode->GetDocument()->GetNotify()->OnCreateLayoutItem(pFormNode);
 }
 
 void CXFA_LayoutPageMgr::SaveLayoutItem(CXFA_LayoutItem* pParentLayoutItem) {
   CXFA_LayoutItem* pNextLayoutItem;
@@ skipping 100 matching lines @@
     ASSERT(pRootPageSetContainerItem->m_pFormNode->GetElementType() ==
            XFA_Element::PageSet);
     if (iIndex < pDocument->m_pPendingPageSet.GetSize()) {
       pPendingPageSet = pDocument->m_pPendingPageSet.GetAt(iIndex);
       iIndex++;
     }
     if (!pPendingPageSet) {
       if (pRootPageSetContainerItem->m_pFormNode->GetPacketID() ==
           XFA_XDPPACKET_Template) {
         pPendingPageSet =
-            pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(FALSE);
+            pRootPageSetContainerItem->m_pFormNode->CloneTemplateToForm(false);
       } else {
         pPendingPageSet = pRootPageSetContainerItem->m_pFormNode;
       }
     }
     if (pRootPageSetContainerItem->m_pFormNode->GetUserData(
             XFA_LAYOUTITEMKEY) == pRootPageSetContainerItem) {
       pRootPageSetContainerItem->m_pFormNode->SetUserData(XFA_LAYOUTITEMKEY,
                                                           nullptr);
     }
     pRootPageSetContainerItem->m_pFormNode = pPendingPageSet;
     pPendingPageSet->ClearFlag(XFA_NodeFlag_UnusedNode);
     for (CXFA_ContainerLayoutItem* pContainerItem = iterator.MoveToNext();
          pContainerItem; pContainerItem = iterator.MoveToNext()) {
       CXFA_Node* pNode = pContainerItem->m_pFormNode;
       if (pNode->GetPacketID() != XFA_XDPPACKET_Template)
         continue;
 
       switch (pNode->GetElementType()) {
         case XFA_Element::PageSet: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           pContainerItem->m_pFormNode = XFA_NodeMerge_CloneOrMergeContainer(
-              pDocument, pParentNode, pContainerItem->m_pFormNode, TRUE,
+              pDocument, pParentNode, pContainerItem->m_pFormNode, true,
               nullptr);
           break;
         }
         case XFA_Element::PageArea: {
           CXFA_ContainerLayoutItem* pFormLayout = pContainerItem;
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
-          FX_BOOL bIsExistForm = TRUE;
+          bool bIsExistForm = true;
           for (int32_t iLevel = 0; iLevel < 3; iLevel++) {
             pFormLayout = static_cast<CXFA_ContainerLayoutItem*>(
                 pFormLayout->m_pFirstChild);
             if (iLevel == 2) {
               while (pFormLayout &&
                      !XFA_ItemLayoutProcessor_IsTakingSpace(
                          pFormLayout->m_pFormNode)) {
                 pFormLayout = static_cast<CXFA_ContainerLayoutItem*>(
                     pFormLayout->m_pNextSibling);
               }
             }
             if (!pFormLayout) {
-              bIsExistForm = FALSE;
+              bIsExistForm = false;
               break;
             }
           }
           if (bIsExistForm) {
             CXFA_Node* pNewSubform = pFormLayout->m_pFormNode;
             if (pContainerItem->m_pOldSubform &&
                 pContainerItem->m_pOldSubform != pNewSubform) {
               CXFA_Node* pExistingNode = XFA_DataMerge_FindFormDOMInstance(
                   pDocument, pContainerItem->m_pFormNode->GetElementType(),
                   pContainerItem->m_pFormNode->GetNameHash(), pParentNode);
@@ skipping 10 matching lines @@
                 }
               }
               if (pExistingNode) {
                 pParentNode->RemoveChild(pExistingNode);
               }
             }
             pContainerItem->m_pOldSubform = pNewSubform;
           }
           pContainerItem->m_pFormNode = pDocument->DataMerge_CopyContainer(
               pContainerItem->m_pFormNode, pParentNode,
-              ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), TRUE, TRUE,
-              TRUE);
+              ToNode(pDocument->GetXFAObject(XFA_HASHCODE_Record)), true, true,
+              true);
           break;
         }
         case XFA_Element::ContentArea: {
           CXFA_Node* pParentNode = pContainerItem->m_pParent->m_pFormNode;
           for (CXFA_Node* pChildNode =
                    pParentNode->GetNodeItem(XFA_NODEITEM_FirstChild);
                pChildNode;
                pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
             if (pChildNode->GetTemplateNode() != pContainerItem->m_pFormNode) {
               continue;
@@ skipping 113 matching lines @@
                                     CXFA_TraverseStrategy_LayoutItem>
               iterator(pContainerItem);
           CXFA_LayoutItem* pChildLayoutItem = iterator.GetCurrent();
           while (pChildLayoutItem) {
             CXFA_ContentLayoutItem* pContentItem =
                 pChildLayoutItem->AsContentLayoutItem();
             if (!pContentItem) {
               pChildLayoutItem = iterator.MoveToNext();
               continue;
             }
-            FX_BOOL bVisible =
+            bool bVisible =
                 (pContentItem->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Presence) ==
                  XFA_ATTRIBUTEENUM_Visible);
             uint32_t dwRelevantChild =
                 GetRelevant(pContentItem->m_pFormNode, dwRelevant);
             SyncContainer(pNotify, m_pLayoutProcessor, pContentItem,
                           dwRelevantChild, bVisible, nPageIdx);
             pChildLayoutItem = iterator.SkipChildrenAndMoveToNext();
           }
           break;
         }
@@ skipping 42 matching lines @@
       XFA_ReleaseLayoutItem(pRootLayoutItem);
       m_pPageSetLayoutItemRoot = nullptr;
       pRootLayoutItem = nullptr;
       pPageSetFormNode = nullptr;
       m_PageArray.RemoveAll();
     }
     while (pPageSetFormNode) {
       CXFA_Node* pNextPageSet =
           pPageSetFormNode->GetNextSameClassSibling(XFA_Element::PageSet);
       pPageSetFormNode->GetNodeItem(XFA_NODEITEM_Parent)
-          ->RemoveChild(pPageSetFormNode, FALSE);
+          ->RemoveChild(pPageSetFormNode, false);
       pRootLayoutItem->m_pFormNode->GetDocument()->m_pPendingPageSet.Add(
           pPageSetFormNode);
       pPageSetFormNode = pNextPageSet;
     }
   }
   pRootLayoutItem = m_pPageSetLayoutItemRoot;
   CXFA_ContainerLayoutItem* pNextLayout = nullptr;
   for (; pRootLayoutItem; pRootLayoutItem = pNextLayout) {
     pNextLayout =
         static_cast<CXFA_ContainerLayoutItem*>(pRootLayoutItem->m_pNextSibling);
     SaveLayoutItem(pRootLayoutItem);
     delete pRootLayoutItem;
   }
   m_pPageSetLayoutItemRoot = nullptr;
 }