Remove FX_BOOL from xfa.

xfa/fxfa/parser/xfa_layout_itemlayout.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/xfa_layout_itemlayout.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 15 matching lines @@
                         int32_t iStrLen,
                         FX_WCHAR delimiter,
                         CFX_WideStringArray& pieces) {
   if (!pStr)
     return 0;
   if (iStrLen < 0)
     iStrLen = FXSYS_wcslen(pStr);
 
   const FX_WCHAR* pToken = pStr;
   const FX_WCHAR* pEnd = pStr + iStrLen;
-  while (TRUE) {
+  while (true) {
     if (pStr >= pEnd || delimiter == *pStr) {
       CFX_WideString sub(pToken, pStr - pToken);
       pieces.Add(sub);
       pToken = pStr + 1;
       if (pStr >= pEnd)
         break;
     }
     pStr++;
   }
   return pieces.GetSize();
 }
 
 }  // namespace
 
 CXFA_ItemLayoutProcessor::CXFA_ItemLayoutProcessor(CXFA_Node* pNode,
                                                    CXFA_LayoutPageMgr* pPageMgr)
-    : m_bKeepBreakFinish(FALSE),
-      m_bIsProcessKeep(FALSE),
+    : m_bKeepBreakFinish(false),
+      m_bIsProcessKeep(false),
       m_pKeepHeadNode(nullptr),
       m_pKeepTailNode(nullptr),
       m_pFormNode(pNode),
       m_pLayoutItem(nullptr),
       m_pOldLayoutItem(nullptr),
       m_pCurChildNode(XFA_LAYOUT_INVALIDNODE),
       m_pCurChildPreprocessor(nullptr),
       m_nCurChildNodeStage(XFA_ItemLayoutProcessorStages_None),
       m_fUsedSize(0),
       m_pPageMgr(pPageMgr),
-      m_bBreakPending(TRUE),
+      m_bBreakPending(true),
       m_fLastRowWidth(0),
       m_fLastRowY(0),
       m_fWidthLimite(0),
-      m_bUseInheriated(FALSE),
+      m_bUseInheriated(false),
       m_ePreProcessRs(XFA_ItemLayoutProcessorResult_Done),
-      m_bHasAvailHeight(TRUE) {
+      m_bHasAvailHeight(true) {
   ASSERT(m_pFormNode && (m_pFormNode->IsContainerNode() ||
                          m_pFormNode->GetElementType() == XFA_Element::Form));
   m_pOldLayoutItem =
       (CXFA_ContentLayoutItem*)m_pFormNode->GetUserData(XFA_LAYOUTITEMKEY);
 }
 
 CXFA_ItemLayoutProcessor::~CXFA_ItemLayoutProcessor() {}
 
 CXFA_ContentLayoutItem* CXFA_ItemLayoutProcessor::CreateContentLayoutItem(
     CXFA_Node* pFormNode) {
@@ skipping 15 matching lines @@
     while (pPrevLayoutItem->m_pNext) {
       pPrevLayoutItem = pPrevLayoutItem->m_pNext;
     }
     pPrevLayoutItem->m_pNext = pLayoutItem;
     pLayoutItem->m_pPrev = pPrevLayoutItem;
   } else {
     pFormNode->SetUserData(XFA_LAYOUTITEMKEY, pLayoutItem);
   }
   return pLayoutItem;
 }
-FX_BOOL CXFA_ItemLayoutProcessor::FindLayoutItemSplitPos(
+bool CXFA_ItemLayoutProcessor::FindLayoutItemSplitPos(
     CXFA_ContentLayoutItem* pLayoutItem,
     FX_FLOAT fCurVerticalOffset,
     FX_FLOAT& fProposedSplitPos,
-    FX_BOOL& bAppChange,
-    FX_BOOL bCalculateMargin) {
+    bool& bAppChange,
+    bool bCalculateMargin) {
   CXFA_Node* pFormNode = pLayoutItem->m_pFormNode;
   if (fProposedSplitPos > fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION &&
       fProposedSplitPos <= fCurVerticalOffset + pLayoutItem->m_sSize.y -
                                XFA_LAYOUT_FLOAT_PERCISION) {
     switch (pFormNode->GetIntact()) {
       case XFA_ATTRIBUTEENUM_None: {
-        FX_BOOL bAnyChanged = FALSE;
+        bool bAnyChanged = false;
         CXFA_Document* pDocument = pFormNode->GetDocument();
         CXFA_FFNotify* pNotify = pDocument->GetNotify();
         FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
         CXFA_Node* pMarginNode =
             pFormNode->GetFirstChildByClass(XFA_Element::Margin);
         if (pMarginNode && bCalculateMargin) {
           fCurTopMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset)
                               .ToUnit(XFA_UNIT_Pt);
           fCurBottomMargin = pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset)
                                  .ToUnit(XFA_UNIT_Pt);
         }
-        FX_BOOL bChanged = TRUE;
+        bool bChanged = true;
         while (bChanged) {
-          bChanged = FALSE;
+          bChanged = false;
           {
             FX_FLOAT fRelSplitPos = fProposedSplitPos - fCurVerticalOffset;
             if (pNotify->FindSplitPos(pFormNode, pLayoutItem->GetIndex(),
                                       fRelSplitPos)) {
-              bAnyChanged = TRUE;
-              bChanged = TRUE;
+              bAnyChanged = true;
+              bChanged = true;
               fProposedSplitPos = fCurVerticalOffset + fRelSplitPos;
-              bAppChange = TRUE;
+              bAppChange = true;
               if (fProposedSplitPos <=
                   fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION) {
-                return TRUE;
+                return true;
               }
             }
           }
           FX_FLOAT fRelSplitPos = fProposedSplitPos - fCurBottomMargin;
           for (CXFA_ContentLayoutItem* pChildItem =
                    (CXFA_ContentLayoutItem*)pLayoutItem->m_pFirstChild;
                pChildItem;
                pChildItem =
                    (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling) {
             FX_FLOAT fChildOffset =
                 fCurVerticalOffset + fCurTopMargin + pChildItem->m_sPos.y;
-            FX_BOOL bChange = FALSE;
+            bool bChange = false;
             if (FindLayoutItemSplitPos(pChildItem, fChildOffset, fRelSplitPos,
                                        bChange, bCalculateMargin)) {
               if (fRelSplitPos - fChildOffset < XFA_LAYOUT_FLOAT_PERCISION &&
                   bChange) {
                 fProposedSplitPos = fRelSplitPos - fCurTopMargin;
               } else {
                 fProposedSplitPos = fRelSplitPos + fCurBottomMargin;
               }
-              bAnyChanged = TRUE;
-              bChanged = TRUE;
+              bAnyChanged = true;
+              bChanged = true;
               if (fProposedSplitPos <=
                   fCurVerticalOffset + XFA_LAYOUT_FLOAT_PERCISION) {
-                return TRUE;
+                return true;
               }
               if (bAnyChanged) {
                 break;
               }
             }
           }
         }
         return bAnyChanged;
       } break;
       case XFA_ATTRIBUTEENUM_ContentArea:
       case XFA_ATTRIBUTEENUM_PageArea: {
         fProposedSplitPos = fCurVerticalOffset;
-        return TRUE;
+        return true;
       }
       default:
-        return FALSE;
+        return false;
     }
   }
-  return FALSE;
+  return false;
 }
-static XFA_ATTRIBUTEENUM XFA_ItemLayoutProcessor_GetLayout(
-    CXFA_Node* pFormNode,
-    FX_BOOL& bRootForceTb) {
-  bRootForceTb = FALSE;
+static XFA_ATTRIBUTEENUM XFA_ItemLayoutProcessor_GetLayout(CXFA_Node* pFormNode,
+                                                           bool& bRootForceTb) {
+  bRootForceTb = false;
   XFA_ATTRIBUTEENUM eLayoutMode;
-  if (pFormNode->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, FALSE)) {
+  if (pFormNode->TryEnum(XFA_ATTRIBUTE_Layout, eLayoutMode, false)) {
     return eLayoutMode;
   }
   CXFA_Node* pParentNode = pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
   if (pParentNode && pParentNode->GetElementType() == XFA_Element::Form) {
-    bRootForceTb = TRUE;
+    bRootForceTb = true;
     return XFA_ATTRIBUTEENUM_Tb;
   }
   return XFA_ATTRIBUTEENUM_Position;
 }
-static FX_BOOL XFA_ExistContainerKeep(CXFA_Node* pCurNode, FX_BOOL bPreFind) {
+static bool XFA_ExistContainerKeep(CXFA_Node* pCurNode, bool bPreFind) {
   if (!pCurNode || !XFA_ItemLayoutProcessor_IsTakingSpace(pCurNode)) {
-    return FALSE;
+    return false;
   }
   XFA_NODEITEM eItemType = XFA_NODEITEM_PrevSibling;
   if (!bPreFind) {
     eItemType = XFA_NODEITEM_NextSibling;
   }
   CXFA_Node* pPreContainer =
       pCurNode->GetNodeItem(eItemType, XFA_ObjectType::ContainerNode);
   if (!pPreContainer) {
-    return FALSE;
+    return false;
   }
   CXFA_Node* pKeep = pCurNode->GetFirstChildByClass(XFA_Element::Keep);
   if (pKeep) {
     XFA_ATTRIBUTEENUM ePrevious;
     XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Previous;
     if (!bPreFind) {
       eKeepType = XFA_ATTRIBUTE_Next;
     }
-    if (pKeep->TryEnum(eKeepType, ePrevious, FALSE)) {
+    if (pKeep->TryEnum(eKeepType, ePrevious, false)) {
       if (ePrevious == XFA_ATTRIBUTEENUM_ContentArea ||
           ePrevious == XFA_ATTRIBUTEENUM_PageArea) {
-        return TRUE;
+        return true;
       }
     }
   }
   pKeep = pPreContainer->GetFirstChildByClass(XFA_Element::Keep);
   if (!pKeep) {
-    return FALSE;
+    return false;
   }
   XFA_ATTRIBUTEENUM eNext;
   XFA_ATTRIBUTE eKeepType = XFA_ATTRIBUTE_Next;
   if (!bPreFind) {
     eKeepType = XFA_ATTRIBUTE_Previous;
   }
-  if (!pKeep->TryEnum(eKeepType, eNext, FALSE)) {
-    return FALSE;
+  if (!pKeep->TryEnum(eKeepType, eNext, false)) {
+    return false;
   }
   if (eNext == XFA_ATTRIBUTEENUM_ContentArea ||
       eNext == XFA_ATTRIBUTEENUM_PageArea) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 FX_FLOAT CXFA_ItemLayoutProcessor::FindSplitPos(FX_FLOAT fProposedSplitPos) {
   ASSERT(m_pLayoutItem);
   XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  FX_BOOL bCalculateMargin = TRUE;
+  bool bCalculateMargin = true;
   if (eLayout == XFA_ATTRIBUTEENUM_Position) {
-    bCalculateMargin = FALSE;
+    bCalculateMargin = false;
   }
   while (fProposedSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
-    FX_BOOL bAppChange = FALSE;
+    bool bAppChange = false;
     if (!FindLayoutItemSplitPos(m_pLayoutItem, 0, fProposedSplitPos, bAppChange,
                                 bCalculateMargin)) {
       break;
     }
   }
   return fProposedSplitPos;
 }
 void CXFA_ItemLayoutProcessor::SplitLayoutItem(
     CXFA_ContentLayoutItem* pLayoutItem,
     CXFA_ContentLayoutItem* pSecondParent,
     FX_FLOAT fSplitPos) {
   FX_FLOAT fCurTopMargin = 0, fCurBottomMargin = 0;
   XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
-  FX_BOOL bCalculateMargin = TRUE;
+  bool bCalculateMargin = true;
   if (eLayout == XFA_ATTRIBUTEENUM_Position) {
-    bCalculateMargin = FALSE;
+    bCalculateMargin = false;
   }
   CXFA_Node* pMarginNode =
       pLayoutItem->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   if (pMarginNode && bCalculateMargin) {
     fCurTopMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fCurBottomMargin =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
   }
   CXFA_ContentLayoutItem* pSecondLayoutItem = nullptr;
@@ skipping 33 matching lines @@
   pLayoutItem->m_pFirstChild = nullptr;
   FX_FLOAT lHeightForKeep = 0;
   CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
   FX_FLOAT fAddMarginHeight = 0;
   for (CXFA_ContentLayoutItem *pChildItem = pChildren, *pChildNext = nullptr;
        pChildItem; pChildItem = pChildNext) {
     pChildNext = (CXFA_ContentLayoutItem*)pChildItem->m_pNextSibling;
     pChildItem->m_pNextSibling = nullptr;
     if (fSplitPos <= fCurTopMargin + pChildItem->m_sPos.y + fCurBottomMargin +
                          XFA_LAYOUT_FLOAT_PERCISION) {
-      if (!XFA_ExistContainerKeep(pChildItem->m_pFormNode, TRUE)) {
+      if (!XFA_ExistContainerKeep(pChildItem->m_pFormNode, true)) {
         pChildItem->m_sPos.y -= fSplitPos - fCurBottomMargin;
         pChildItem->m_sPos.y += lHeightForKeep;
         pChildItem->m_sPos.y += fAddMarginHeight;
         pSecondLayoutItem->AddChild(pChildItem);
       } else {
         if (lHeightForKeep < XFA_LAYOUT_FLOAT_PERCISION) {
           for (int32_t iIndex = 0; iIndex < keepLayoutItems.GetSize();
                iIndex++) {
             CXFA_ContentLayoutItem* pPreItem = keepLayoutItems[iIndex];
             pLayoutItem->RemoveChild(pPreItem);
@@ skipping 14 matching lines @@
         }
         pChildItem->m_sPos.y -= fSplitPos;
         pChildItem->m_sPos.y += lHeightForKeep;
         pChildItem->m_sPos.y += fAddMarginHeight;
         pSecondLayoutItem->AddChild(pChildItem);
       }
     } else if (fSplitPos + XFA_LAYOUT_FLOAT_PERCISION >=
                fCurTopMargin + fCurBottomMargin + pChildItem->m_sPos.y +
                    pChildItem->m_sSize.y) {
       pLayoutItem->AddChild(pChildItem);
-      if (XFA_ExistContainerKeep(pChildItem->m_pFormNode, FALSE)) {
+      if (XFA_ExistContainerKeep(pChildItem->m_pFormNode, false)) {
         keepLayoutItems.Add(pChildItem);
       } else {
         keepLayoutItems.RemoveAll();
       }
     } else {
       FX_FLOAT fOldHeight = pSecondLayoutItem->m_sSize.y;
       SplitLayoutItem(
           pChildItem, pSecondLayoutItem,
           fSplitPos - fCurTopMargin - fCurBottomMargin - pChildItem->m_sPos.y);
       fAddMarginHeight = pSecondLayoutItem->m_sSize.y - fOldHeight;
@@ skipping 12 matching lines @@
     if (pCurNode->m_pFormNode->GetElementType() == XFA_Element::PageArea)
       return static_cast<CXFA_ContainerLayoutItem*>(pCurNode);
   }
   return nullptr;
 }
 
 CXFA_Node* CXFA_LayoutItem::GetFormNode() const {
   return m_pFormNode;
 }
 
-void CXFA_LayoutItem::GetRect(CFX_RectF& rtLayout, FX_BOOL bRelative) const {
+void CXFA_LayoutItem::GetRect(CFX_RectF& rtLayout, bool bRelative) const {
   ASSERT(m_bIsContentLayoutItem);
   const CXFA_ContentLayoutItem* pThis =
       static_cast<const CXFA_ContentLayoutItem*>(this);
   CFX_PointF sPos = pThis->m_sPos;
   CFX_SizeF sSize = pThis->m_sSize;
   if (!bRelative) {
     for (CXFA_LayoutItem* pLayoutItem = pThis->m_pParent; pLayoutItem;
          pLayoutItem = pLayoutItem->m_pParent) {
       if (CXFA_ContentLayoutItem* pContent =
               pLayoutItem->AsContentLayoutItem()) {
@@ skipping 182 matching lines @@
     CXFA_ContentLayoutItem* pNextOldLayoutItem = pOldLayoutItem->m_pNext;
     pNotify->OnLayoutItemRemoving(pDocLayout, pOldLayoutItem);
     if (pOldLayoutItem->m_pParent)
       pOldLayoutItem->m_pParent->RemoveChild(pOldLayoutItem);
     delete pOldLayoutItem;
     pOldLayoutItem = pNextOldLayoutItem;
   }
   m_pOldLayoutItem = nullptr;
   return pLayoutItem;
 }
-static FX_BOOL XFA_ItemLayoutProcessor_FindBreakNode(
+static bool XFA_ItemLayoutProcessor_FindBreakNode(
     CXFA_Node* pContainerNode,
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
-    FX_BOOL bBreakBefore) {
-  FX_BOOL bFindRs = FALSE;
+    bool bBreakBefore) {
+  bool bFindRs = false;
   for (CXFA_Node* pBreakNode = pContainerNode; pBreakNode;
        pBreakNode = pBreakNode->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     XFA_ATTRIBUTE eAttributeType = XFA_ATTRIBUTE_Before;
     if (!bBreakBefore) {
       eAttributeType = XFA_ATTRIBUTE_After;
     }
     switch (pBreakNode->GetElementType()) {
       case XFA_Element::BreakBefore: {
         if (bBreakBefore) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
-          bFindRs = TRUE;
+          bFindRs = true;
         }
       } break;
       case XFA_Element::BreakAfter: {
         if (!bBreakBefore) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
-          bFindRs = TRUE;
+          bFindRs = true;
         }
       } break;
       case XFA_Element::Break:
         if (pBreakNode->GetEnum(eAttributeType) != XFA_ATTRIBUTEENUM_Auto) {
           pCurActionNode = pBreakNode;
           nCurStage = XFA_ItemLayoutProcessorStages_BreakBefore;
           if (!bBreakBefore) {
             nCurStage = XFA_ItemLayoutProcessorStages_BreakAfter;
           }
-          bFindRs = TRUE;
+          bFindRs = true;
           break;
         }
       default:
         break;
     }
     if (bFindRs) {
       break;
     }
   }
   return bFindRs;
@@ skipping 15 matching lines @@
       delete pCurLayoutItem;
       pCurLayoutItem = pNextLayoutItem;
     }
   }
   pGenerateNode->GetNodeItem(XFA_NODEITEM_Parent)->RemoveChild(pGenerateNode);
 }
 void CXFA_ItemLayoutProcessor::XFA_ItemLayoutProcessor_GotoNextContainerNode(
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     CXFA_Node* pParentContainer,
-    FX_BOOL bUsePageBreak) {
+    bool bUsePageBreak) {
   CXFA_Node* pEntireContainer = pParentContainer;
   CXFA_Node* pChildContainer = XFA_LAYOUT_INVALIDNODE;
   switch (nCurStage) {
     case XFA_ItemLayoutProcessorStages_BreakBefore:
     case XFA_ItemLayoutProcessorStages_BreakAfter: {
       pChildContainer = pCurActionNode->GetNodeItem(XFA_NODEITEM_Parent);
     } break;
     case XFA_ItemLayoutProcessorStages_Keep:
     case XFA_ItemLayoutProcessorStages_Container:
       pChildContainer = pCurActionNode;
       break;
     default:
       pChildContainer = XFA_LAYOUT_INVALIDNODE;
       break;
   }
   switch (nCurStage) {
     case XFA_ItemLayoutProcessorStages_Keep: {
       CXFA_Node* pBreakAfterNode =
           pChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild);
       if (!m_bKeepBreakFinish &&
           XFA_ItemLayoutProcessor_FindBreakNode(pBreakAfterNode, pCurActionNode,
-                                                nCurStage, FALSE)) {
+                                                nCurStage, false)) {
         return;
       }
       goto CheckNextChildContainer;
     }
     case XFA_ItemLayoutProcessorStages_None: {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BookendLeader:
         for (CXFA_Node* pBookendNode =
                  pCurActionNode == XFA_LAYOUT_INVALIDNODE
                      ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild)
@@ skipping 12 matching lines @@
         }
     }
       {
         pCurActionNode = XFA_LAYOUT_INVALIDNODE;
         case XFA_ItemLayoutProcessorStages_BreakBefore:
           if (pCurActionNode != XFA_LAYOUT_INVALIDNODE) {
             CXFA_Node* pBreakBeforeNode =
                 pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
             if (!m_bKeepBreakFinish &&
                 XFA_ItemLayoutProcessor_FindBreakNode(
-                    pBreakBeforeNode, pCurActionNode, nCurStage, TRUE)) {
+                    pBreakBeforeNode, pCurActionNode, nCurStage, true)) {
               return;
             }
             if (m_bIsProcessKeep) {
               if (ProcessKeepNodesForBreakBefore(pCurActionNode, nCurStage,
                                                  pChildContainer)) {
                 return;
               }
               goto CheckNextChildContainer;
             }
             pCurActionNode = pChildContainer;
             nCurStage = XFA_ItemLayoutProcessorStages_Container;
             return;
           }
           goto CheckNextChildContainer;
       }
     case XFA_ItemLayoutProcessorStages_Container: {
       pCurActionNode = XFA_LAYOUT_INVALIDNODE;
       case XFA_ItemLayoutProcessorStages_BreakAfter: {
         if (pCurActionNode == XFA_LAYOUT_INVALIDNODE) {
           CXFA_Node* pBreakAfterNode =
               pChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild);
           if (!m_bKeepBreakFinish &&
               XFA_ItemLayoutProcessor_FindBreakNode(
-                  pBreakAfterNode, pCurActionNode, nCurStage, FALSE)) {
+                  pBreakAfterNode, pCurActionNode, nCurStage, false)) {
             return;
           }
         } else {
           CXFA_Node* pBreakAfterNode =
               pCurActionNode->GetNodeItem(XFA_NODEITEM_NextSibling);
           if (XFA_ItemLayoutProcessor_FindBreakNode(
-                  pBreakAfterNode, pCurActionNode, nCurStage, FALSE)) {
+                  pBreakAfterNode, pCurActionNode, nCurStage, false)) {
             return;
           }
         }
         goto CheckNextChildContainer;
       }
     }
     CheckNextChildContainer : {
       CXFA_Node* pNextChildContainer =
           pChildContainer == XFA_LAYOUT_INVALIDNODE
               ? pEntireContainer->GetNodeItem(XFA_NODEITEM_FirstChild,
                                               XFA_ObjectType::ContainerNode)
               : pChildContainer->GetNodeItem(XFA_NODEITEM_NextSibling,
                                              XFA_ObjectType::ContainerNode);
       while (pNextChildContainer &&
              pNextChildContainer->IsLayoutGeneratedNode()) {
         CXFA_Node* pSaveNode = pNextChildContainer;
         pNextChildContainer = pNextChildContainer->GetNodeItem(
             XFA_NODEITEM_NextSibling, XFA_ObjectType::ContainerNode);
         if (pSaveNode->IsUnusedNode())
           XFA_DeleteLayoutGeneratedNode(pSaveNode);
       }
       if (!pNextChildContainer) {
         goto NoMoreChildContainer;
       }
-      FX_BOOL bLastKeep = FALSE;
+      bool bLastKeep = false;
       if (ProcessKeepNodesForCheckNext(pCurActionNode, nCurStage,
                                        pNextChildContainer, bLastKeep)) {
         return;
       }
       if (!m_bKeepBreakFinish && !bLastKeep &&
           XFA_ItemLayoutProcessor_FindBreakNode(
               pNextChildContainer->GetNodeItem(XFA_NODEITEM_FirstChild),
-              pCurActionNode, nCurStage, TRUE)) {
+              pCurActionNode, nCurStage, true)) {
         return;
       }
       pCurActionNode = pNextChildContainer;
       if (m_bIsProcessKeep) {
         nCurStage = XFA_ItemLayoutProcessorStages_Keep;
       } else {
         nCurStage = XFA_ItemLayoutProcessorStages_Container;
       }
       return;
     }
@@ skipping 15 matching lines @@
             default:
               break;
           }
         }
     }
     default:
       pCurActionNode = nullptr;
       nCurStage = XFA_ItemLayoutProcessorStages_Done;
   }
 }
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForCheckNext(
+bool CXFA_ItemLayoutProcessor::ProcessKeepNodesForCheckNext(
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     CXFA_Node*& pNextContainer,
-    FX_BOOL& bLastKeepNode) {
+    bool& bLastKeepNode) {
   const bool bCanSplit = pNextContainer->GetIntact() == XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bNextKeep = FALSE;
-  if (XFA_ExistContainerKeep(pNextContainer, FALSE)) {
-    bNextKeep = TRUE;
+  bool bNextKeep = false;
+  if (XFA_ExistContainerKeep(pNextContainer, false)) {
+    bNextKeep = true;
   }
   if (bNextKeep && !bCanSplit) {
     if (!m_bIsProcessKeep && !m_bKeepBreakFinish) {
       m_pKeepHeadNode = pNextContainer;
-      m_bIsProcessKeep = TRUE;
+      m_bIsProcessKeep = true;
     }
   } else {
     if (m_bIsProcessKeep && m_pKeepHeadNode) {
       m_pKeepTailNode = pNextContainer;
       if (!m_bKeepBreakFinish &&
           XFA_ItemLayoutProcessor_FindBreakNode(
               pNextContainer->GetNodeItem(XFA_NODEITEM_FirstChild),
-              pCurActionNode, nCurStage, TRUE)) {
-        return TRUE;
+              pCurActionNode, nCurStage, true)) {
+        return true;
       } else {
         pNextContainer = m_pKeepHeadNode;
-        m_bKeepBreakFinish = TRUE;
+        m_bKeepBreakFinish = true;
         m_pKeepHeadNode = nullptr;
         m_pKeepTailNode = nullptr;
-        m_bIsProcessKeep = FALSE;
+        m_bIsProcessKeep = false;
       }
     } else {
       if (m_bKeepBreakFinish) {
-        bLastKeepNode = TRUE;
+        bLastKeepNode = true;
       }
-      m_bKeepBreakFinish = FALSE;
+      m_bKeepBreakFinish = false;
     }
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepNodesForBreakBefore(
+bool CXFA_ItemLayoutProcessor::ProcessKeepNodesForBreakBefore(
     CXFA_Node*& pCurActionNode,
     XFA_ItemLayoutProcessorStages& nCurStage,
     CXFA_Node* pContainerNode) {
   if (m_pKeepTailNode == pContainerNode) {
     pCurActionNode = m_pKeepHeadNode;
-    m_bKeepBreakFinish = TRUE;
+    m_bKeepBreakFinish = true;
     m_pKeepHeadNode = nullptr;
     m_pKeepTailNode = nullptr;
-    m_bIsProcessKeep = FALSE;
+    m_bIsProcessKeep = false;
     nCurStage = XFA_ItemLayoutProcessorStages_Container;
-    return TRUE;
+    return true;
   }
   CXFA_Node* pBreakAfterNode =
       pContainerNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   if (XFA_ItemLayoutProcessor_FindBreakNode(pBreakAfterNode, pCurActionNode,
-                                            nCurStage, FALSE)) {
-    return TRUE;
+                                            nCurStage, false)) {
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL XFA_ItemLayoutProcessor_IsTakingSpace(CXFA_Node* pNode) {
+bool XFA_ItemLayoutProcessor_IsTakingSpace(CXFA_Node* pNode) {
   XFA_ATTRIBUTEENUM ePresence = pNode->GetEnum(XFA_ATTRIBUTE_Presence);
   return ePresence == XFA_ATTRIBUTEENUM_Visible ||
          ePresence == XFA_ATTRIBUTEENUM_Invisible;
 }
 static inline void XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
     CXFA_Node* pFormNode,
     FX_FLOAT& fContainerWidth,
     FX_FLOAT& fContainerHeight,
-    FX_BOOL& bContainerWidthAutoSize,
-    FX_BOOL& bContainerHeightAutoSize) {
+    bool& bContainerWidthAutoSize,
+    bool& bContainerHeightAutoSize) {
   fContainerWidth = 0;
   fContainerHeight = 0;
-  bContainerWidthAutoSize = TRUE;
-  bContainerHeightAutoSize = TRUE;
+  bContainerWidthAutoSize = true;
+  bContainerHeightAutoSize = true;
   XFA_Element eType = pFormNode->GetElementType();
   CXFA_Measurement mTmpValue;
   if (bContainerWidthAutoSize &&
       (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup) &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_W, mTmpValue, FALSE) &&
+      pFormNode->TryMeasure(XFA_ATTRIBUTE_W, mTmpValue, false) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerWidthAutoSize = FALSE;
+    bContainerWidthAutoSize = false;
   }
   if (bContainerHeightAutoSize &&
       (eType == XFA_Element::Subform || eType == XFA_Element::ExclGroup) &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_H, mTmpValue, FALSE) &&
+      pFormNode->TryMeasure(XFA_ATTRIBUTE_H, mTmpValue, false) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerHeightAutoSize = FALSE;
+    bContainerHeightAutoSize = false;
   }
   if (bContainerWidthAutoSize && eType == XFA_Element::Subform &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxW, mTmpValue, FALSE) &&
+      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxW, mTmpValue, false) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerWidth = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerWidthAutoSize = FALSE;
+    bContainerWidthAutoSize = false;
   }
   if (bContainerHeightAutoSize && eType == XFA_Element::Subform &&
-      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxH, mTmpValue, FALSE) &&
+      pFormNode->TryMeasure(XFA_ATTRIBUTE_MaxH, mTmpValue, false) &&
       mTmpValue.GetValue() > XFA_LAYOUT_FLOAT_PERCISION) {
     fContainerHeight = mTmpValue.ToUnit(XFA_UNIT_Pt);
-    bContainerHeightAutoSize = FALSE;
+    bContainerHeightAutoSize = false;
   }
 }
 static inline void
 XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
     CXFA_Node* pFormNode,
-    FX_BOOL bContainerWidthAutoSize,
+    bool bContainerWidthAutoSize,
     FX_FLOAT fContentCalculatedWidth,
     FX_FLOAT& fContainerWidth,
-    FX_BOOL bContainerHeightAutoSize,
+    bool bContainerHeightAutoSize,
     FX_FLOAT fContentCalculatedHeight,
     FX_FLOAT& fContainerHeight) {
   CXFA_Node* pMarginNode = pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   CXFA_Measurement mTmpValue;
   if (bContainerWidthAutoSize) {
     fContainerWidth = fContentCalculatedWidth;
     if (pMarginNode) {
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_LeftInset, mTmpValue, FALSE)) {
+      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_LeftInset, mTmpValue, false)) {
         fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_RightInset, mTmpValue, FALSE)) {
+      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_RightInset, mTmpValue, false)) {
         fContainerWidth += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
     }
   }
   if (bContainerHeightAutoSize) {
     fContainerHeight = fContentCalculatedHeight;
     if (pMarginNode) {
-      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_TopInset, mTmpValue, FALSE)) {
+      if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_TopInset, mTmpValue, false)) {
         fContainerHeight += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
       if (pMarginNode->TryMeasure(XFA_ATTRIBUTE_BottomInset, mTmpValue,
-                                  FALSE)) {
+                                  false)) {
         fContainerHeight += mTmpValue.ToUnit(XFA_UNIT_Pt);
       }
     }
   }
 }
 void CXFA_ItemLayoutProcessor::CalculatePositionedContainerPos(
     CXFA_Node* pNode,
     FX_FLOAT fWidth,
     FX_FLOAT fHeight,
     FX_FLOAT& fAbsoluteX,
@@ skipping 58 matching lines @@
     case 1:
       fAbsoluteX -= fWidth / 2;
       break;
     case 2:
       fAbsoluteX -= fWidth;
       break;
     default:
       break;
   }
 }
-FX_BOOL CXFA_ItemLayoutProcessor::IncrementRelayoutNode(
+bool CXFA_ItemLayoutProcessor::IncrementRelayoutNode(
     CXFA_LayoutProcessor* pLayoutProcessor,
     CXFA_Node* pNode,
     CXFA_Node* pParentNode) {
-  return FALSE;
+  return false;
 }
 void CXFA_ItemLayoutProcessor::DoLayoutPageArea(
     CXFA_ContainerLayoutItem* pPageAreaLayoutItem) {
   CXFA_Node* pFormNode = pPageAreaLayoutItem->m_pFormNode;
   CXFA_Node* pCurChildNode = XFA_LAYOUT_INVALIDNODE;
   XFA_ItemLayoutProcessorStages nCurChildNodeStage =
       XFA_ItemLayoutProcessorStages_None;
   CXFA_LayoutItem* pBeforeItem = nullptr;
   for (XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           pCurChildNode, nCurChildNodeStage, pFormNode, FALSE);
+           pCurChildNode, nCurChildNodeStage, pFormNode, false);
        pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           pCurChildNode, nCurChildNodeStage, pFormNode, FALSE)) {
+           pCurChildNode, nCurChildNodeStage, pFormNode, false)) {
     if (nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
     if (pCurChildNode->GetElementType() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(pCurChildNode, nullptr);
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
+    pProcessor->DoLayout(false, XFA_LAYOUT_FLOAT_MAX);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     FX_FLOAT fWidth, fHeight;
     pProcessor->GetCurrentComponentSize(fWidth, fHeight);
     FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
     CalculatePositionedContainerPos(pCurChildNode, fWidth, fHeight, fAbsoluteX,
                                     fAbsoluteY);
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
@@ skipping 26 matching lines @@
       pLayoutItem = pNextLayoutItem;
     }
   }
 }
 void CXFA_ItemLayoutProcessor::DoLayoutPositionedContainer(
     CXFA_LayoutContext* pContext) {
   if (m_pLayoutItem)
     return;
 
   m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
-  FX_BOOL bIgnoreXY = (m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout) !=
-                       XFA_ATTRIBUTEENUM_Position);
+  bool bIgnoreXY = (m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout) !=
+                    XFA_ATTRIBUTEENUM_Position);
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
+  bool bContainerWidthAutoSize = true, bContainerHeightAutoSize = true;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
       bContainerHeightAutoSize);
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   FX_FLOAT fHiddenContentCalculatedWidth = 0,
            fHiddenContentCalculatedHeight = 0;
   if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
+        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, false);
   }
   int32_t iColIndex = 0;
   for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
+           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, false)) {
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
     if (m_pCurChildNode->GetElementType() == XFA_Element::Variables) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
     if (pContext && pContext->m_prgSpecifiedColumnWidths) {
       int32_t iColSpan = m_pCurChildNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
       if (iColSpan <=
           pContext->m_prgSpecifiedColumnWidths->GetSize() - iColIndex) {
         pContext->m_fCurColumnWidth = 0;
-        pContext->m_bCurColumnWidthAvaiable = TRUE;
+        pContext->m_bCurColumnWidthAvaiable = true;
         if (iColSpan == -1)
           iColSpan = pContext->m_prgSpecifiedColumnWidths->GetSize();
         for (int32_t i = 0; iColIndex + i < iColSpan; ++i) {
           pContext->m_fCurColumnWidth +=
               pContext->m_prgSpecifiedColumnWidths->GetAt(iColIndex + i);
         }
         if (pContext->m_fCurColumnWidth == 0)
-          pContext->m_bCurColumnWidthAvaiable = FALSE;
+          pContext->m_bCurColumnWidthAvaiable = false;
         iColIndex += iColSpan >= 0 ? iColSpan : 0;
       }
     }
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
+    pProcessor->DoLayout(false, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
                          pContext);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     FX_FLOAT fWidth, fHeight;
     pProcessor->GetCurrentComponentSize(fWidth, fHeight);
-    FX_BOOL bChangeParentSize = FALSE;
+    bool bChangeParentSize = false;
     if (XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
-      bChangeParentSize = TRUE;
+      bChangeParentSize = true;
     }
     FX_FLOAT fAbsoluteX = 0, fAbsoluteY = 0;
     if (!bIgnoreXY) {
       CalculatePositionedContainerPos(m_pCurChildNode, fWidth, fHeight,
                                       fAbsoluteX, fAbsoluteY);
     }
     pProcessor->SetCurrentComponentPos(fAbsoluteX, fAbsoluteY);
     if (bContainerWidthAutoSize) {
       FX_FLOAT fChildSuppliedWidth = fAbsoluteX + fWidth;
       if (bChangeParentSize) {
@@ skipping 55 matching lines @@
       }
       break;
     }
     case XFA_Element::Draw:
     case XFA_Element::Field: {
       pNode->GetDocument()->GetNotify()->StartFieldDrawLayout(pNode, fWidth,
                                                               fHeight);
       break;
     }
     default:
-      ASSERT(FALSE);
+      ASSERT(false);
   }
 }
 static inline void XFA_ItemLayoutProcessor_RelocateTableRowCells(
     CXFA_ContentLayoutItem* pLayoutRow,
     const CFX_ArrayTemplate<FX_FLOAT>& rgSpecifiedColumnWidths,
     XFA_ATTRIBUTEENUM eLayout) {
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
+  bool bContainerWidthAutoSize = true, bContainerHeightAutoSize = true;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       pLayoutRow->m_pFormNode, fContainerWidth, fContainerHeight,
       bContainerWidthAutoSize, bContainerHeightAutoSize);
   CXFA_Node* pMarginNode =
       pLayoutRow->m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fTopInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
     fBottomInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
   }
   FX_FLOAT fContentWidthLimit =
       bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
                               : fContainerWidth - fLeftInset - fRightInset;
   FX_FLOAT fContentCurrentHeight =
       pLayoutRow->m_sSize.y - fTopInset - fBottomInset;
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   FX_FLOAT fCurrentColX = 0;
   int32_t nCurrentColIdx = 0;
-  FX_BOOL bMetWholeRowCell = FALSE;
+  bool bMetWholeRowCell = false;
   for (CXFA_ContentLayoutItem* pLayoutChild =
            (CXFA_ContentLayoutItem*)pLayoutRow->m_pFirstChild;
        pLayoutChild;
        pLayoutChild = (CXFA_ContentLayoutItem*)pLayoutChild->m_pNextSibling) {
     int32_t nOriginalColSpan =
         pLayoutChild->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
     int32_t nColSpan = nOriginalColSpan;
     FX_FLOAT fColSpanWidth = 0;
     if (nColSpan == -1 ||
         nCurrentColIdx + nColSpan > rgSpecifiedColumnWidths.GetSize()) {
       nColSpan = rgSpecifiedColumnWidths.GetSize() - nCurrentColIdx;
     }
     for (int32_t i = 0; i < nColSpan; i++) {
       fColSpanWidth += rgSpecifiedColumnWidths[nCurrentColIdx + i];
     }
     if (nColSpan != nOriginalColSpan) {
       fColSpanWidth = bMetWholeRowCell ? 0 : std::max(fColSpanWidth,
                                                       pLayoutChild->m_sSize.y);
     }
     if (nOriginalColSpan == -1) {
-      bMetWholeRowCell = TRUE;
+      bMetWholeRowCell = true;
     }
     pLayoutChild->m_sPos = CFX_PointF(fCurrentColX, 0);
     pLayoutChild->m_sSize.x = fColSpanWidth;
     if (XFA_ItemLayoutProcessor_IsTakingSpace(pLayoutChild->m_pFormNode)) {
       fCurrentColX += fColSpanWidth;
       nCurrentColIdx += nColSpan;
       FX_FLOAT fNewHeight =
           bContainerHeightAutoSize ? -1 : fContentCurrentHeight;
       XFA_ItemLayoutProcessor_UpdateWidgetSize(pLayoutChild, fColSpanWidth,
                                                fNewHeight);
@@ skipping 74 matching lines @@
 void CXFA_ItemLayoutProcessor::DoLayoutTableContainer(CXFA_Node* pLayoutNode) {
   if (m_pLayoutItem)
     return;
 
   if (!pLayoutNode) {
     pLayoutNode = m_pFormNode;
   }
   ASSERT(m_pCurChildNode == XFA_LAYOUT_INVALIDNODE);
   m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
+  bool bContainerWidthAutoSize = true, bContainerHeightAutoSize = true;
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
       bContainerHeightAutoSize);
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   CXFA_Node* pMarginNode =
       m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0;
   FX_FLOAT fRightInset = 0;
   if (pMarginNode) {
     fLeftInset =
@@ skipping 21 matching lines @@
       }
     }
   }
   int32_t iSpecifiedColumnCount = m_rgSpecifiedColumnWidths.GetSize();
   CXFA_LayoutContext layoutContext;
   layoutContext.m_prgSpecifiedColumnWidths = &m_rgSpecifiedColumnWidths;
   CXFA_LayoutContext* pLayoutContext =
       iSpecifiedColumnCount > 0 ? &layoutContext : nullptr;
   if (m_pCurChildNode == XFA_LAYOUT_INVALIDNODE) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE);
+        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, false);
   }
   for (; m_pCurChildNode; XFA_ItemLayoutProcessor_GotoNextContainerNode(
-           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, FALSE)) {
-    layoutContext.m_bCurColumnWidthAvaiable = FALSE;
+           m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, false)) {
+    layoutContext.m_bCurColumnWidthAvaiable = false;
     layoutContext.m_fCurColumnWidth = 0;
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Container) {
       continue;
     }
     CXFA_ItemLayoutProcessor* pProcessor =
         new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
-    pProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
+    pProcessor->DoLayout(false, XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX,
                          pLayoutContext);
     if (!pProcessor->HasLayoutItem()) {
       delete pProcessor;
       continue;
     }
     m_pLayoutItem->AddChild(pProcessor->ExtractLayoutItem());
     delete pProcessor;
   }
   int32_t iRowCount = 0, iColCount = 0;
   {
@@ skipping 20 matching lines @@
               (CXFA_ContentLayoutItem*)pLayoutChild->m_pFirstChild) {
         rgRowItems.Add(pRowLayoutCell);
         int32_t iColSpan =
             pRowLayoutCell->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan);
         rgRowItemsSpan.Add(iColSpan);
         rgRowItemsWidth.Add(pRowLayoutCell->m_sSize.x);
       }
     }
     iRowCount = rgRowItems.GetSize();
     iColCount = 0;
-    FX_BOOL bMoreColumns = TRUE;
+    bool bMoreColumns = true;
     while (bMoreColumns) {
-      bMoreColumns = FALSE;
-      FX_BOOL bAutoCol = FALSE;
+      bMoreColumns = false;
+      bool bAutoCol = false;
       for (int32_t i = 0; i < iRowCount; i++) {
         while (rgRowItems[i] && (rgRowItemsSpan[i] <= 0 ||
                                  !XFA_ItemLayoutProcessor_IsTakingSpace(
                                      rgRowItems[i]->m_pFormNode))) {
           CXFA_ContentLayoutItem* pNewCell =
               (CXFA_ContentLayoutItem*)rgRowItems[i]->m_pNextSibling;
           if (rgRowItemsSpan[i] < 0 && XFA_ItemLayoutProcessor_IsTakingSpace(
                                            rgRowItems[i]->m_pFormNode)) {
             pNewCell = nullptr;
           }
           rgRowItems[i] = pNewCell;
           rgRowItemsSpan[i] =
               pNewCell
                   ? pNewCell->m_pFormNode->GetInteger(XFA_ATTRIBUTE_ColSpan)
                   : 0;
           rgRowItemsWidth[i] = pNewCell ? pNewCell->m_sSize.x : 0;
         }
         CXFA_ContentLayoutItem* pCell = rgRowItems[i];
         if (!pCell) {
           continue;
         }
-        bMoreColumns = TRUE;
+        bMoreColumns = true;
         if (rgRowItemsSpan[i] == 1) {
           if (iColCount >= iSpecifiedColumnCount) {
             for (int32_t j = 0, c = iColCount + 1 -
                                     m_rgSpecifiedColumnWidths.GetSize();
                  j < c; j++) {
               m_rgSpecifiedColumnWidths.Add(0);
             }
           }
           if (m_rgSpecifiedColumnWidths[iColCount] <
               XFA_LAYOUT_FLOAT_PERCISION) {
-            bAutoCol = TRUE;
+            bAutoCol = true;
           }
           if (bAutoCol &&
               m_rgSpecifiedColumnWidths[iColCount] < rgRowItemsWidth[i]) {
             m_rgSpecifiedColumnWidths[iColCount] = rgRowItemsWidth[i];
           }
         }
       }
       if (bMoreColumns) {
         FX_FLOAT fFinalColumnWidth = 0.0f;
         if (iColCount < m_rgSpecifiedColumnWidths.GetSize())
@@ skipping 88 matching lines @@
   switch (eLayout) {
     case XFA_ATTRIBUTEENUM_Row:
     case XFA_ATTRIBUTEENUM_Rl_row:
       XFA_ItemLayoutProcessor_RelocateTableRowCells(
           pLayoutItem, pProcessor->m_rgSpecifiedColumnWidths, eLayout);
       break;
     default:
       break;
   }
 }
-FX_BOOL CXFA_ItemLayoutProcessor::IsAddNewRowForTrailer(
+bool CXFA_ItemLayoutProcessor::IsAddNewRowForTrailer(
     CXFA_ContentLayoutItem* pTrailerItem) {
   if (!pTrailerItem) {
-    return FALSE;
+    return false;
   }
   FX_FLOAT fWidth = pTrailerItem->m_sSize.x;
   XFA_ATTRIBUTEENUM eLayout = m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
   if (eLayout != XFA_ATTRIBUTEENUM_Tb && m_fWidthLimite > fWidth) {
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 static void XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
     CXFA_ItemLayoutProcessor* pProcessor,
     FX_FLOAT fSplitPos,
     CXFA_ContentLayoutItem* pTrailerLayoutItem,
-    FX_BOOL bUseInherited = FALSE) {
+    bool bUseInherited = false) {
   if (!pTrailerLayoutItem) {
     return;
   }
   FX_FLOAT fHeight = pTrailerLayoutItem->m_sSize.y;
   if (bUseInherited) {
     FX_FLOAT fNewSplitPos = 0;
     if (fSplitPos - fHeight > XFA_LAYOUT_FLOAT_PERCISION) {
       fNewSplitPos = pProcessor->FindSplitPos(fSplitPos - fHeight);
     }
     if (fNewSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
@@ skipping 90 matching lines @@
            pLeaderLayoutItem->m_sSize.x) /
           2;
       break;
   }
   pProcessor->m_pLayoutItem->m_sSize.y += fHeight;
   pProcessor->m_pLayoutItem->AddChild(pLeaderLayoutItem);
 }
 static void XFA_ItemLayoutProcessor_AddPendingNode(
     CXFA_ItemLayoutProcessor* pProcessor,
     CXFA_Node* pPendingNode,
-    FX_BOOL bBreakPending) {
+    bool bBreakPending) {
   pProcessor->m_PendingNodes.push_back(pPendingNode);
   pProcessor->m_bBreakPending = bBreakPending;
 }
 static FX_FLOAT XFA_ItemLayoutProcessor_InsertPendingItems(
     CXFA_ItemLayoutProcessor* pProcessor,
     CXFA_Node* pCurChildNode) {
   FX_FLOAT fTotalHeight = 0;
   if (pProcessor->m_PendingNodes.empty()) {
     return fTotalHeight;
   }
   if (!pProcessor->m_pLayoutItem) {
     pProcessor->m_pLayoutItem =
         pProcessor->CreateContentLayoutItem(pCurChildNode);
     pProcessor->m_pLayoutItem->m_sSize.clear();
   }
   while (!pProcessor->m_PendingNodes.empty()) {
     std::unique_ptr<CXFA_ItemLayoutProcessor> pPendingProcessor(
         new CXFA_ItemLayoutProcessor(pProcessor->m_PendingNodes.front(),
                                      nullptr));
     pProcessor->m_PendingNodes.pop_front();
-    pPendingProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
+    pPendingProcessor->DoLayout(false, XFA_LAYOUT_FLOAT_MAX);
     CXFA_ContentLayoutItem* pPendingLayoutItem =
         pPendingProcessor->HasLayoutItem()
             ? pPendingProcessor->ExtractLayoutItem()
             : nullptr;
     if (pPendingLayoutItem) {
       XFA_ItemLayoutProcessor_AddLeaderAfterSplit(pProcessor,
                                                   pPendingLayoutItem);
       if (pProcessor->m_bBreakPending) {
         fTotalHeight += pPendingLayoutItem->m_sSize.y;
       }
@@ skipping 11 matching lines @@
     for (int32_t iIndex = m_arrayKeepItems.GetSize() - 1; iIndex >= 0;
          iIndex--) {
       XFA_ItemLayoutProcessor_AddLeaderAfterSplit(this,
                                                   m_arrayKeepItems[iIndex]);
       fTotalHeight += m_arrayKeepItems[iIndex]->m_sSize.y;
     }
     m_arrayKeepItems.RemoveAll();
   }
   return fTotalHeight;
 }
-FX_BOOL CXFA_ItemLayoutProcessor::ProcessKeepForSplite(
+bool CXFA_ItemLayoutProcessor::ProcessKeepForSplite(
     CXFA_ItemLayoutProcessor* pParentProcessor,
     CXFA_ItemLayoutProcessor* pChildProcessor,
     XFA_ItemLayoutProcessorResult eRetValue,
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& rgCurLineLayoutItem,
     FX_FLOAT& fContentCurRowAvailWidth,
     FX_FLOAT& fContentCurRowHeight,
     FX_FLOAT& fContentCurRowY,
-    FX_BOOL& bAddedItemInRow,
-    FX_BOOL& bForceEndPage,
+    bool& bAddedItemInRow,
+    bool& bForceEndPage,
     XFA_ItemLayoutProcessorResult& result) {
   if (!pParentProcessor || !pChildProcessor) {
-    return FALSE;
+    return false;
   }
   if (pParentProcessor->m_pCurChildNode->GetIntact() !=
           XFA_ATTRIBUTEENUM_None ||
       !pChildProcessor->m_bHasAvailHeight) {
-    if (XFA_ExistContainerKeep(pParentProcessor->m_pCurChildNode, TRUE)) {
+    if (XFA_ExistContainerKeep(pParentProcessor->m_pCurChildNode, true)) {
       FX_FLOAT fChildWidth, fChildHeight;
       pChildProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
       CFX_ArrayTemplate<CXFA_ContentLayoutItem*> keepLayoutItems;
       if (pParentProcessor->JudgePutNextPage(pParentProcessor->m_pLayoutItem,
                                              fChildHeight, keepLayoutItems)) {
         m_arrayKeepItems.RemoveAll();
         for (int32_t iIndex = 0; iIndex < keepLayoutItems.GetSize(); iIndex++) {
           CXFA_ContentLayoutItem* pItem = keepLayoutItems.GetAt(iIndex);
           pParentProcessor->m_pLayoutItem->RemoveChild(pItem);
           fContentCurRowY -= pItem->m_sSize.y;
           m_arrayKeepItems.Add(pItem);
         }
-        bAddedItemInRow = TRUE;
-        bForceEndPage = TRUE;
+        bAddedItemInRow = true;
+        bForceEndPage = true;
         result = XFA_ItemLayoutProcessorResult_PageFullBreak;
-        return TRUE;
+        return true;
       }
       rgCurLineLayoutItem.Add(pChildProcessor->ExtractLayoutItem());
-      bAddedItemInRow = TRUE;
+      bAddedItemInRow = true;
       fContentCurRowAvailWidth -= fChildWidth;
       if (fContentCurRowHeight < fChildHeight) {
         fContentCurRowHeight = fChildHeight;
       }
       result = eRetValue;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXFA_ItemLayoutProcessor::JudgePutNextPage(
+bool CXFA_ItemLayoutProcessor::JudgePutNextPage(
     CXFA_ContentLayoutItem* pParentLayoutItem,
     FX_FLOAT fChildHeight,
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*>& pKeepItems) {
   if (!pParentLayoutItem) {
-    return FALSE;
+    return false;
   }
   FX_FLOAT fItemsHeight = 0;
   for (CXFA_ContentLayoutItem* pChildLayoutItem =
            (CXFA_ContentLayoutItem*)pParentLayoutItem->m_pFirstChild;
        pChildLayoutItem;
        pChildLayoutItem =
            (CXFA_ContentLayoutItem*)pChildLayoutItem->m_pNextSibling) {
-    if (XFA_ExistContainerKeep(pChildLayoutItem->m_pFormNode, FALSE)) {
+    if (XFA_ExistContainerKeep(pChildLayoutItem->m_pFormNode, false)) {
       pKeepItems.Add(pChildLayoutItem);
       fItemsHeight += pChildLayoutItem->m_sSize.y;
     } else {
       pKeepItems.RemoveAll();
       fItemsHeight = 0;
     }
   }
   fItemsHeight += fChildHeight;
   if (m_pPageMgr->GetNextAvailContentHeight(fItemsHeight)) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 void CXFA_ItemLayoutProcessor::ProcessUnUseBinds(CXFA_Node* pFormNode) {
   if (!pFormNode) {
     return;
   }
   CXFA_NodeIteratorTemplate<CXFA_Node, CXFA_TraverseStrategy_XFANode> sIterator(
       pFormNode);
   for (CXFA_Node* pNode = sIterator.MoveToNext(); pNode;
        pNode = sIterator.MoveToNext()) {
     if (pNode->IsContainerNode()) {
@@ skipping 26 matching lines @@
   if (pTrailerNode && pFormNode) {
     pFormNode->RemoveChild(pTrailerNode);
   }
   if (pTrailerItem) {
     XFA_ReleaseLayoutItem(pTrailerItem);
   }
 }
 static XFA_ItemLayoutProcessorResult XFA_ItemLayoutProcessor_InsertFlowedItem(
     CXFA_ItemLayoutProcessor* pThis,
     CXFA_ItemLayoutProcessor* pProcessor,
-    FX_BOOL bContainerWidthAutoSize,
-    FX_BOOL bContainerHeightAutoSize,
+    bool bContainerWidthAutoSize,
+    bool bContainerHeightAutoSize,
     FX_FLOAT fContainerHeight,
     XFA_ATTRIBUTEENUM eFlowStrategy,
     uint8_t& uCurHAlignState,
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> (&rgCurLineLayoutItems)[3],
-    FX_BOOL bUseBreakControl,
+    bool bUseBreakControl,
     FX_FLOAT fAvailHeight,
     FX_FLOAT fRealHeight,
     FX_FLOAT& fContentCurRowY,
     FX_FLOAT& fContentWidthLimit,
     FX_FLOAT& fContentCurRowAvailWidth,
     FX_FLOAT& fContentCurRowHeight,
-    FX_BOOL& bAddedItemInRow,
-    FX_BOOL& bForceEndPage,
+    bool& bAddedItemInRow,
+    bool& bForceEndPage,
     CXFA_LayoutContext* pLayoutContext = nullptr,
-    FX_BOOL bNewRow = FALSE) {
-  FX_BOOL bTakeSpace =
+    bool bNewRow = false) {
+  bool bTakeSpace =
       XFA_ItemLayoutProcessor_IsTakingSpace(pProcessor->m_pFormNode);
   uint8_t uHAlign = XFA_ItemLayoutProcessor_HAlignEnumToInt(
       pThis->m_pCurChildNode->GetEnum(XFA_ATTRIBUTE_HAlign));
   if (bContainerWidthAutoSize) {
     uHAlign = 0;
   }
   if ((eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb && uHAlign < uCurHAlignState) ||
       (eFlowStrategy == XFA_ATTRIBUTEENUM_Rl_tb && uHAlign > uCurHAlignState)) {
     return XFA_ItemLayoutProcessorResult_RowFullBreak;
   }
   uCurHAlignState = uHAlign;
-  FX_BOOL bIsOwnSplite =
+  bool bIsOwnSplite =
       pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bUseRealHeight =
+  bool bUseRealHeight =
       bTakeSpace && bContainerHeightAutoSize && bIsOwnSplite &&
       pProcessor->m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)->GetIntact() ==
           XFA_ATTRIBUTEENUM_None;
-  FX_BOOL bIsTransHeight = bTakeSpace;
+  bool bIsTransHeight = bTakeSpace;
   if (bIsTransHeight && !bIsOwnSplite) {
-    FX_BOOL bRootForceTb = FALSE;
+    bool bRootForceTb = false;
     XFA_ATTRIBUTEENUM eLayoutStrategy = XFA_ItemLayoutProcessor_GetLayout(
         pProcessor->m_pFormNode, bRootForceTb);
     if (eLayoutStrategy == XFA_ATTRIBUTEENUM_Lr_tb ||
         eLayoutStrategy == XFA_ATTRIBUTEENUM_Rl_tb) {
-      bIsTransHeight = FALSE;
+      bIsTransHeight = false;
     }
   }
-  FX_BOOL bUseInherited = FALSE;
+  bool bUseInherited = false;
   CXFA_LayoutContext layoutContext;
   if (pThis->m_pPageMgr) {
     CXFA_Node* pOverflowNode =
         pThis->m_pPageMgr->QueryOverflow(pThis->m_pFormNode);
     if (pOverflowNode) {
       layoutContext.m_pOverflowNode = pOverflowNode;
       layoutContext.m_pOverflowProcessor = pThis;
       pLayoutContext = &layoutContext;
     }
   }
   XFA_ItemLayoutProcessorResult eRetValue = XFA_ItemLayoutProcessorResult_Done;
   if (!bNewRow ||
       pProcessor->m_ePreProcessRs == XFA_ItemLayoutProcessorResult_Done) {
     eRetValue = pProcessor->DoLayout(
-        bTakeSpace ? bUseBreakControl : FALSE,
+        bTakeSpace ? bUseBreakControl : false,
         bUseRealHeight ? fRealHeight - fContentCurRowY : XFA_LAYOUT_FLOAT_MAX,
         bIsTransHeight ? fRealHeight - fContentCurRowY : XFA_LAYOUT_FLOAT_MAX,
         pLayoutContext);
     pProcessor->m_ePreProcessRs = eRetValue;
   } else {
     eRetValue = pProcessor->m_ePreProcessRs;
     pProcessor->m_ePreProcessRs = XFA_ItemLayoutProcessorResult_Done;
   }
-  if (pProcessor->HasLayoutItem() == FALSE) {
+  if (pProcessor->HasLayoutItem() == false) {
     return eRetValue;
   }
   FX_FLOAT fChildWidth, fChildHeight;
   pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
   if (bUseRealHeight && fRealHeight < XFA_LAYOUT_FLOAT_PERCISION) {
     fRealHeight = XFA_LAYOUT_FLOAT_MAX;
     fAvailHeight = XFA_LAYOUT_FLOAT_MAX;
   }
   if (!bTakeSpace ||
       (fChildWidth <= fContentCurRowAvailWidth + XFA_LAYOUT_FLOAT_PERCISION) ||
       (fContentWidthLimit - fContentCurRowAvailWidth <=
        XFA_LAYOUT_FLOAT_PERCISION)) {
     CXFA_Node* pOverflowLeaderNode = nullptr;
     CXFA_Node* pOverflowTrailerNode = nullptr;
     CXFA_Node* pFormNode = nullptr;
     CXFA_ContentLayoutItem* pTrailerLayoutItem = nullptr;
-    FX_BOOL bIsAddTrailerHeight = FALSE;
+    bool bIsAddTrailerHeight = false;
     if (pThis->m_pPageMgr &&
         pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
       pFormNode = pThis->m_pPageMgr->QueryOverflow(pProcessor->m_pFormNode);
       if (!pFormNode && pLayoutContext &&
           pLayoutContext->m_pOverflowProcessor) {
         pFormNode = pLayoutContext->m_pOverflowNode;
-        bUseInherited = TRUE;
+        bUseInherited = true;
       }
       if (pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                             pOverflowTrailerNode, FALSE,
-                                             FALSE)) {
+                                             pOverflowTrailerNode, false,
+                                             false)) {
         if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowTrailerNode)) {
           if (pOverflowTrailerNode) {
             CXFA_ItemLayoutProcessor* pOverflowLeaderProcessor =
                 new CXFA_ItemLayoutProcessor(pOverflowTrailerNode, nullptr);
-            pOverflowLeaderProcessor->DoLayout(FALSE, XFA_LAYOUT_FLOAT_MAX);
+            pOverflowLeaderProcessor->DoLayout(false, XFA_LAYOUT_FLOAT_MAX);
             pTrailerLayoutItem =
                 pOverflowLeaderProcessor->HasLayoutItem()
                     ? pOverflowLeaderProcessor->ExtractLayoutItem()
                     : nullptr;
             delete pOverflowLeaderProcessor;
           }
           if (bUseInherited) {
             bIsAddTrailerHeight =
                 pThis->IsAddNewRowForTrailer(pTrailerLayoutItem);
           } else {
             bIsAddTrailerHeight =
                 pProcessor->IsAddNewRowForTrailer(pTrailerLayoutItem);
           }
           if (bIsAddTrailerHeight) {
             FX_FLOAT fTrailerHeight = pTrailerLayoutItem->m_sSize.y;
             fChildHeight += fTrailerHeight;
-            bIsAddTrailerHeight = TRUE;
+            bIsAddTrailerHeight = true;
           }
         }
       }
     }
     if (!bTakeSpace ||
         fContentCurRowY + fChildHeight <=
             fAvailHeight + XFA_LAYOUT_FLOAT_PERCISION ||
         (!bContainerHeightAutoSize &&
          pThis->m_fUsedSize + fAvailHeight + XFA_LAYOUT_FLOAT_PERCISION >=
              fContainerHeight)) {
       if (!bTakeSpace || eRetValue == XFA_ItemLayoutProcessorResult_Done) {
         if (pProcessor->m_bUseInheriated) {
           if (pTrailerLayoutItem) {
             XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
                 pProcessor, fChildHeight, pTrailerLayoutItem);
           }
           if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
             XFA_ItemLayoutProcessor_AddPendingNode(pProcessor,
-                                                   pOverflowLeaderNode, FALSE);
+                                                   pOverflowLeaderNode, false);
           }
-          pProcessor->m_bUseInheriated = FALSE;
+          pProcessor->m_bUseInheriated = false;
         } else {
           if (bIsAddTrailerHeight) {
             fChildHeight -= pTrailerLayoutItem->m_sSize.y;
           }
           pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                            pOverflowTrailerNode,
                                            pTrailerLayoutItem, pFormNode);
         }
         CXFA_ContentLayoutItem* pChildLayoutItem =
             pProcessor->ExtractLayoutItem();
-        if (XFA_ExistContainerKeep(pProcessor->m_pFormNode, FALSE) &&
+        if (XFA_ExistContainerKeep(pProcessor->m_pFormNode, false) &&
             pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None) {
           pThis->m_arrayKeepItems.Add(pChildLayoutItem);
         } else {
           pThis->m_arrayKeepItems.RemoveAll();
         }
         rgCurLineLayoutItems[uHAlign].Add(pChildLayoutItem);
-        bAddedItemInRow = TRUE;
+        bAddedItemInRow = true;
         if (bTakeSpace) {
           fContentCurRowAvailWidth -= fChildWidth;
           if (fContentCurRowHeight < fChildHeight) {
             fContentCurRowHeight = fChildHeight;
           }
         }
         return XFA_ItemLayoutProcessorResult_Done;
       } else {
         if (eRetValue == XFA_ItemLayoutProcessorResult_PageFullBreak) {
           if (pProcessor->m_bUseInheriated) {
             if (pTrailerLayoutItem) {
               XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
                   pProcessor, fChildHeight, pTrailerLayoutItem);
             }
             if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
               XFA_ItemLayoutProcessor_AddPendingNode(
-                  pProcessor, pOverflowLeaderNode, FALSE);
+                  pProcessor, pOverflowLeaderNode, false);
             }
-            pProcessor->m_bUseInheriated = FALSE;
+            pProcessor->m_bUseInheriated = false;
           } else {
             if (bIsAddTrailerHeight) {
               fChildHeight -= pTrailerLayoutItem->m_sSize.y;
             }
             pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                              pOverflowTrailerNode,
                                              pTrailerLayoutItem, pFormNode);
           }
         }
         rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-        bAddedItemInRow = TRUE;
+        bAddedItemInRow = true;
         fContentCurRowAvailWidth -= fChildWidth;
         if (fContentCurRowHeight < fChildHeight) {
           fContentCurRowHeight = fChildHeight;
         }
         return eRetValue;
       }
     } else {
       XFA_ItemLayoutProcessorResult eResult;
       if (pThis->ProcessKeepForSplite(
               pThis, pProcessor, eRetValue, rgCurLineLayoutItems[uHAlign],
               fContentCurRowAvailWidth, fContentCurRowHeight, fContentCurRowY,
               bAddedItemInRow, bForceEndPage, eResult)) {
         return eResult;
       }
-      bForceEndPage = TRUE;
+      bForceEndPage = true;
       FX_FLOAT fSplitPos =
           pProcessor->FindSplitPos(fAvailHeight - fContentCurRowY);
       if (fSplitPos > XFA_LAYOUT_FLOAT_PERCISION) {
         XFA_ATTRIBUTEENUM eLayout =
             pProcessor->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (eLayout == XFA_ATTRIBUTEENUM_Tb &&
             eRetValue == XFA_ItemLayoutProcessorResult_Done) {
           pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                            pOverflowTrailerNode,
                                            pTrailerLayoutItem, pFormNode);
           rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-          bAddedItemInRow = TRUE;
+          bAddedItemInRow = true;
           if (bTakeSpace) {
             fContentCurRowAvailWidth -= fChildWidth;
             if (fContentCurRowHeight < fChildHeight) {
               fContentCurRowHeight = fChildHeight;
             }
           }
           return XFA_ItemLayoutProcessorResult_PageFullBreak;
         }
         CXFA_Node* pTempLeaderNode = nullptr;
         CXFA_Node* pTempTrailerNode = nullptr;
         if (pThis->m_pPageMgr && !pProcessor->m_bUseInheriated &&
             eRetValue != XFA_ItemLayoutProcessorResult_PageFullBreak) {
           pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
-                                             pTempTrailerNode, FALSE, TRUE);
+                                             pTempTrailerNode, false, true);
         }
         if (pTrailerLayoutItem && bIsAddTrailerHeight) {
           XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(
               pProcessor, fSplitPos, pTrailerLayoutItem, bUseInherited);
         } else {
           pProcessor->SplitLayoutItem(fSplitPos);
         }
         if (bUseInherited) {
           pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                            pOverflowTrailerNode,
                                            pTrailerLayoutItem, pFormNode);
-          pThis->m_bUseInheriated = TRUE;
+          pThis->m_bUseInheriated = true;
         } else {
           CXFA_LayoutItem* firstChild =
               pProcessor->m_pLayoutItem->m_pFirstChild;
           if (firstChild && !firstChild->m_pNextSibling &&
               firstChild->m_pFormNode->IsLayoutGeneratedNode()) {
             pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                              pOverflowTrailerNode,
                                              pTrailerLayoutItem, pFormNode);
           } else {
             if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
               XFA_ItemLayoutProcessor_AddPendingNode(
-                  pProcessor, pOverflowLeaderNode, FALSE);
+                  pProcessor, pOverflowLeaderNode, false);
             }
           }
         }
         if (pProcessor->m_pLayoutItem->m_pNextSibling) {
           pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
           rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-          bAddedItemInRow = TRUE;
+          bAddedItemInRow = true;
           if (bTakeSpace) {
             fContentCurRowAvailWidth -= fChildWidth;
             if (fContentCurRowHeight < fChildHeight) {
               fContentCurRowHeight = fChildHeight;
             }
           }
         }
         return XFA_ItemLayoutProcessorResult_PageFullBreak;
       } else if (fContentCurRowY <= XFA_LAYOUT_FLOAT_PERCISION) {
         pProcessor->GetCurrentComponentSize(fChildWidth, fChildHeight);
         if (pProcessor->m_pPageMgr->GetNextAvailContentHeight(fChildHeight)) {
           CXFA_Node* pTempLeaderNode = nullptr;
           CXFA_Node* pTempTrailerNode = nullptr;
           if (pThis->m_pPageMgr) {
             if (!pFormNode && pLayoutContext) {
               pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
             }
             pThis->m_pPageMgr->ProcessOverflow(pFormNode, pTempLeaderNode,
-                                               pTempTrailerNode, FALSE, TRUE);
+                                               pTempTrailerNode, false, true);
           }
           if (bUseInherited) {
             pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                              pOverflowTrailerNode,
                                              pTrailerLayoutItem, pFormNode);
-            pThis->m_bUseInheriated = TRUE;
+            pThis->m_bUseInheriated = true;
           }
           return XFA_ItemLayoutProcessorResult_PageFullBreak;
         }
         rgCurLineLayoutItems[uHAlign].Add(pProcessor->ExtractLayoutItem());
-        bAddedItemInRow = TRUE;
+        bAddedItemInRow = true;
         if (bTakeSpace) {
           fContentCurRowAvailWidth -= fChildWidth;
           if (fContentCurRowHeight < fChildHeight) {
             fContentCurRowHeight = fChildHeight;
           }
         }
         if (eRetValue == XFA_ItemLayoutProcessorResult_Done) {
-          bForceEndPage = FALSE;
+          bForceEndPage = false;
         }
         return eRetValue;
       } else {
         XFA_ATTRIBUTEENUM eLayout =
             pProcessor->m_pFormNode->GetEnum(XFA_ATTRIBUTE_Layout);
         if (pProcessor->m_pFormNode->GetIntact() == XFA_ATTRIBUTEENUM_None &&
             eLayout == XFA_ATTRIBUTEENUM_Tb) {
           if (pThis->m_pPageMgr) {
             pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                               pOverflowTrailerNode, FALSE,
-                                               TRUE);
+                                               pOverflowTrailerNode, false,
+                                               true);
           }
           if (pTrailerLayoutItem) {
             XFA_ItemLayoutProcessor_AddTrailerBeforeSplit(pProcessor, fSplitPos,
                                                           pTrailerLayoutItem);
           }
           if (pProcessor->JudgeLeaderOrTrailerForOccur(pOverflowLeaderNode)) {
             XFA_ItemLayoutProcessor_AddPendingNode(pProcessor,
-                                                   pOverflowLeaderNode, FALSE);
+                                                   pOverflowLeaderNode, false);
           }
         } else {
           if (eRetValue == XFA_ItemLayoutProcessorResult_Done) {
             if (!pFormNode && pLayoutContext) {
               pFormNode = pLayoutContext->m_pOverflowProcessor->m_pFormNode;
             }
             if (pThis->m_pPageMgr) {
               pThis->m_pPageMgr->ProcessOverflow(pFormNode, pOverflowLeaderNode,
-                                                 pOverflowTrailerNode, FALSE,
-                                                 TRUE);
+                                                 pOverflowTrailerNode, false,
+                                                 true);
             }
             if (bUseInherited) {
               pProcessor->ProcessUnUseOverFlow(pOverflowLeaderNode,
                                                pOverflowTrailerNode,
                                                pTrailerLayoutItem, pFormNode);
-              pThis->m_bUseInheriated = TRUE;
+              pThis->m_bUseInheriated = true;
             }
           }
         }
         return XFA_ItemLayoutProcessorResult_PageFullBreak;
       }
     }
   } else {
     return XFA_ItemLayoutProcessorResult_RowFullBreak;
   }
   return XFA_ItemLayoutProcessorResult_Done;
 }
 
 XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayoutFlowedContainer(
-    FX_BOOL bUseBreakControl,
+    bool bUseBreakControl,
     XFA_ATTRIBUTEENUM eFlowStrategy,
     FX_FLOAT fHeightLimit,
     FX_FLOAT fRealHeight,
     CXFA_LayoutContext* pContext,
-    FX_BOOL bRootForceTb) {
-  m_bHasAvailHeight = TRUE;
+    bool bRootForceTb) {
+  m_bHasAvailHeight = true;
   FX_FLOAT fContainerWidth = 0, fContainerHeight = 0;
-  FX_BOOL bBreakDone = FALSE;
-  FX_BOOL bContainerWidthAutoSize = TRUE, bContainerHeightAutoSize = TRUE;
-  FX_BOOL bForceEndPage = FALSE;
-  FX_BOOL bIsManualBreak = FALSE;
+  bool bBreakDone = false;
+  bool bContainerWidthAutoSize = true, bContainerHeightAutoSize = true;
+  bool bForceEndPage = false;
+  bool bIsManualBreak = false;
   if (m_pCurChildPreprocessor) {
     m_pCurChildPreprocessor->m_ePreProcessRs =
         XFA_ItemLayoutProcessorResult_Done;
   }
   XFA_ItemLayoutProcessor_CalculateContainerSpecfiedSize(
       m_pFormNode, fContainerWidth, fContainerHeight, bContainerWidthAutoSize,
       bContainerHeightAutoSize);
   if (pContext && pContext->m_bCurColumnWidthAvaiable) {
-    bContainerWidthAutoSize = FALSE;
+    bContainerWidthAutoSize = false;
     fContainerWidth = pContext->m_fCurColumnWidth;
   }
   if (!bContainerHeightAutoSize) {
     fContainerHeight -= m_fUsedSize;
   }
   if (!bContainerHeightAutoSize) {
     CXFA_Node* pParentNode = m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent);
-    FX_BOOL bFocrTb = FALSE;
+    bool bFocrTb = false;
     if (pParentNode &&
         XFA_ItemLayoutProcessor_GetLayout(pParentNode, bFocrTb) ==
             XFA_ATTRIBUTEENUM_Row) {
       CXFA_Node* pChildContainer = m_pFormNode->GetNodeItem(
           XFA_NODEITEM_FirstChild, XFA_ObjectType::ContainerNode);
       if (pChildContainer &&
           pChildContainer->GetNodeItem(XFA_NODEITEM_NextSibling,
                                        XFA_ObjectType::ContainerNode)) {
         fContainerHeight = 0;
-        bContainerHeightAutoSize = TRUE;
+        bContainerHeightAutoSize = true;
       }
     }
   }
   CXFA_Node* pMarginNode =
       m_pFormNode->GetFirstChildByClass(XFA_Element::Margin);
   FX_FLOAT fLeftInset = 0, fTopInset = 0, fRightInset = 0, fBottomInset = 0;
   if (pMarginNode) {
     fLeftInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_LeftInset).ToUnit(XFA_UNIT_Pt);
     fTopInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_TopInset).ToUnit(XFA_UNIT_Pt);
     fRightInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_RightInset).ToUnit(XFA_UNIT_Pt);
     fBottomInset =
         pMarginNode->GetMeasure(XFA_ATTRIBUTE_BottomInset).ToUnit(XFA_UNIT_Pt);
   }
   FX_FLOAT fContentWidthLimit =
       bContainerWidthAutoSize ? XFA_LAYOUT_FLOAT_MAX
                               : fContainerWidth - fLeftInset - fRightInset;
   FX_FLOAT fContentCalculatedWidth = 0, fContentCalculatedHeight = 0;
   FX_FLOAT fAvailHeight = fHeightLimit - fTopInset - fBottomInset;
   if (fAvailHeight < 0) {
-    m_bHasAvailHeight = FALSE;
+    m_bHasAvailHeight = false;
   }
   fRealHeight = fRealHeight - fTopInset - fBottomInset;
   FX_FLOAT fContentCurRowY = 0;
   CXFA_ContentLayoutItem* pLayoutChild = nullptr;
   if (m_pLayoutItem) {
     if (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done &&
         eFlowStrategy != XFA_ATTRIBUTEENUM_Tb) {
       pLayoutChild = (CXFA_ContentLayoutItem*)m_pLayoutItem->m_pFirstChild;
       for (CXFA_ContentLayoutItem* pLayoutNext = pLayoutChild; pLayoutNext;
            pLayoutNext = (CXFA_ContentLayoutItem*)pLayoutNext->m_pNextSibling) {
@@ skipping 23 matching lines @@
     }
     if (pLayoutChild) {
       fContentCurRowY = pLayoutChild->m_sPos.y;
     } else {
       fContentCurRowY = fContentCalculatedHeight;
     }
   }
   fContentCurRowY += InsertKeepLayoutItems();
   if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_None) {
     XFA_ItemLayoutProcessor_GotoNextContainerNode(
-        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
+        m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, true);
   }
   fContentCurRowY +=
       XFA_ItemLayoutProcessor_InsertPendingItems(this, m_pFormNode);
   if (m_pCurChildPreprocessor &&
       m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Container) {
-    if (XFA_ExistContainerKeep(m_pCurChildPreprocessor->GetFormNode(), FALSE)) {
+    if (XFA_ExistContainerKeep(m_pCurChildPreprocessor->GetFormNode(), false)) {
       m_pKeepHeadNode = m_pCurChildNode;
-      m_bIsProcessKeep = TRUE;
+      m_bIsProcessKeep = true;
       m_nCurChildNodeStage = XFA_ItemLayoutProcessorStages_Keep;
     }
   }
   while (m_nCurChildNodeStage != XFA_ItemLayoutProcessorStages_Done) {
     FX_FLOAT fContentCurRowHeight = 0;
     FX_FLOAT fContentCurRowAvailWidth = fContentWidthLimit;
     m_fWidthLimite = fContentCurRowAvailWidth;
     CFX_ArrayTemplate<CXFA_ContentLayoutItem*> rgCurLineLayoutItems[3];
     uint8_t uCurHAlignState =
         (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb ? 0 : 2);
@@ skipping 45 matching lines @@
         pLayoutNextTemp->m_pParent = nullptr;
         CXFA_ContentLayoutItem* pSaveLayoutNext =
             (CXFA_ContentLayoutItem*)pLayoutNextTemp->m_pNextSibling;
         pLayoutNextTemp->m_pNextSibling = nullptr;
         pLayoutNextTemp = pSaveLayoutNext;
       }
       pLayoutChild = nullptr;
     }
     while (m_pCurChildNode) {
       CXFA_ItemLayoutProcessor* pProcessor = nullptr;
-      FX_BOOL bAddedItemInRow = FALSE;
+      bool bAddedItemInRow = false;
       fContentCurRowY +=
           XFA_ItemLayoutProcessor_InsertPendingItems(this, m_pFormNode);
       switch (m_nCurChildNodeStage) {
         case XFA_ItemLayoutProcessorStages_Keep:
         case XFA_ItemLayoutProcessorStages_None:
           break;
         case XFA_ItemLayoutProcessorStages_BreakBefore: {
           for (int32_t iIndex = 0; iIndex < m_arrayKeepItems.GetSize();
                iIndex++) {
             CXFA_ContentLayoutItem* pItem = m_arrayKeepItems.GetAt(iIndex);
             m_pLayoutItem->RemoveChild(pItem);
             fContentCalculatedHeight -= pItem->m_sSize.y;
           }
           CXFA_Node* pLeaderNode = nullptr;
           CXFA_Node* pTrailerNode = nullptr;
-          FX_BOOL bCreatePage = FALSE;
+          bool bCreatePage = false;
           if (bUseBreakControl && m_pPageMgr &&
-              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, TRUE,
+              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, true,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
               m_pFormNode->GetElementType() != XFA_Element::Form &&
               bCreatePage) {
             if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
-              XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
+              XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, true);
             }
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               if (m_pFormNode->GetNodeItem(XFA_NODEITEM_Parent)
                           ->GetElementType() == XFA_Element::Form &&
                   !m_pLayoutItem) {
                 XFA_ItemLayoutProcessor_AddPendingNode(this, pTrailerNode,
-                                                       TRUE);
+                                                       true);
               } else {
                 std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                     new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pTempProcessor.get(), bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, FALSE,
+                    uCurHAlignState, rgCurLineLayoutItems, false,
                     XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext);
               }
             }
             XFA_ItemLayoutProcessor_GotoNextContainerNode(
-                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
-            bForceEndPage = TRUE;
-            bIsManualBreak = TRUE;
+                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, true);
+            bForceEndPage = true;
+            bIsManualBreak = true;
             goto SuspendAndCreateNewRow;
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BreakAfter: {
           CXFA_Node* pLeaderNode = nullptr;
           CXFA_Node* pTrailerNode = nullptr;
-          FX_BOOL bCreatePage = FALSE;
+          bool bCreatePage = false;
           if (bUseBreakControl && m_pPageMgr &&
-              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, FALSE,
+              m_pPageMgr->ProcessBreakBeforeOrAfter(m_pCurChildNode, false,
                                                     pLeaderNode, pTrailerNode,
                                                     bCreatePage) &&
               m_pFormNode->GetElementType() != XFA_Element::Form) {
             if (JudgeLeaderOrTrailerForOccur(pTrailerNode)) {
               std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                   new CXFA_ItemLayoutProcessor(pTrailerNode, nullptr));
               XFA_ItemLayoutProcessor_InsertFlowedItem(
                   this, pTempProcessor.get(), bContainerWidthAutoSize,
                   bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                  uCurHAlignState, rgCurLineLayoutItems, FALSE,
+                  uCurHAlignState, rgCurLineLayoutItems, false,
                   XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                   fContentWidthLimit, fContentCurRowAvailWidth,
                   fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                   pContext);
             }
             if (!bCreatePage) {
               if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
                 CalculateRowChildPosition(
                     rgCurLineLayoutItems, eFlowStrategy,
                     bContainerHeightAutoSize, bContainerWidthAutoSize,
                     fContentCalculatedWidth, fContentCalculatedHeight,
                     fContentCurRowY, fContentCurRowHeight, fContentWidthLimit);
                 rgCurLineLayoutItems->RemoveAll();
                 std::unique_ptr<CXFA_ItemLayoutProcessor> pTempProcessor(
                     new CXFA_ItemLayoutProcessor(pLeaderNode, nullptr));
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pTempProcessor.get(), bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
-                    uCurHAlignState, rgCurLineLayoutItems, FALSE,
+                    uCurHAlignState, rgCurLineLayoutItems, false,
                     XFA_LAYOUT_FLOAT_MAX, XFA_LAYOUT_FLOAT_MAX, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext);
               }
             } else {
               if (JudgeLeaderOrTrailerForOccur(pLeaderNode)) {
-                XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, TRUE);
+                XFA_ItemLayoutProcessor_AddPendingNode(this, pLeaderNode, true);
               }
             }
             XFA_ItemLayoutProcessor_GotoNextContainerNode(
-                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
+                m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, true);
             if (bCreatePage) {
-              bForceEndPage = TRUE;
-              bIsManualBreak = TRUE;
+              bForceEndPage = true;
+              bIsManualBreak = true;
               if (m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done) {
-                bBreakDone = TRUE;
+                bBreakDone = true;
               }
             }
             goto SuspendAndCreateNewRow;
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BookendLeader: {
           CXFA_Node* pLeaderNode = nullptr;
           if (m_pCurChildPreprocessor) {
             pProcessor = m_pCurChildPreprocessor;
             m_pCurChildPreprocessor = nullptr;
           } else if (m_pPageMgr &&
                      m_pPageMgr->ProcessBookendLeaderOrTrailer(
-                         m_pCurChildNode, TRUE, pLeaderNode)) {
+                         m_pCurChildNode, true, pLeaderNode)) {
             pProcessor = new CXFA_ItemLayoutProcessor(pLeaderNode, m_pPageMgr);
           }
           if (pProcessor) {
             if (XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
               pProcessor = nullptr;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_BookendTrailer: {
           CXFA_Node* pTrailerNode = nullptr;
           if (m_pCurChildPreprocessor) {
             pProcessor = m_pCurChildPreprocessor;
             m_pCurChildPreprocessor = nullptr;
           } else if (m_pPageMgr &&
                      m_pPageMgr->ProcessBookendLeaderOrTrailer(
-                         m_pCurChildNode, FALSE, pTrailerNode)) {
+                         m_pCurChildNode, false, pTrailerNode)) {
             pProcessor = new CXFA_ItemLayoutProcessor(pTrailerNode, m_pPageMgr);
           }
           if (pProcessor) {
             if (XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext) != XFA_ItemLayoutProcessorResult_Done) {
               goto SuspendAndCreateNewRow;
             } else {
               delete pProcessor;
               pProcessor = nullptr;
             }
           }
         } break;
         case XFA_ItemLayoutProcessorStages_Container:
           ASSERT(m_pCurChildNode->IsContainerNode());
           if (m_pCurChildNode->GetElementType() == XFA_Element::Variables) {
             break;
           }
           if (fContentCurRowY >= fHeightLimit + XFA_LAYOUT_FLOAT_PERCISION &&
               XFA_ItemLayoutProcessor_IsTakingSpace(m_pCurChildNode)) {
-            bForceEndPage = TRUE;
+            bForceEndPage = true;
             goto SuspendAndCreateNewRow;
           }
           if (m_pCurChildNode->IsContainerNode()) {
-            FX_BOOL bNewRow = FALSE;
+            bool bNewRow = false;
             if (m_pCurChildPreprocessor) {
               pProcessor = m_pCurChildPreprocessor;
               m_pCurChildPreprocessor = nullptr;
-              bNewRow = TRUE;
+              bNewRow = true;
             } else {
               pProcessor =
                   new CXFA_ItemLayoutProcessor(m_pCurChildNode, m_pPageMgr);
             }
             XFA_ItemLayoutProcessor_InsertPendingItems(pProcessor,
                                                        m_pCurChildNode);
             XFA_ItemLayoutProcessorResult rs =
                 XFA_ItemLayoutProcessor_InsertFlowedItem(
                     this, pProcessor, bContainerWidthAutoSize,
                     bContainerHeightAutoSize, fContainerHeight, eFlowStrategy,
                     uCurHAlignState, rgCurLineLayoutItems, bUseBreakControl,
                     fAvailHeight, fRealHeight, fContentCurRowY,
                     fContentWidthLimit, fContentCurRowAvailWidth,
                     fContentCurRowHeight, bAddedItemInRow, bForceEndPage,
                     pContext, bNewRow);
             switch (rs) {
               case XFA_ItemLayoutProcessorResult_ManualBreak:
-                bIsManualBreak = TRUE;
+                bIsManualBreak = true;
               case XFA_ItemLayoutProcessorResult_PageFullBreak:
-                bForceEndPage = TRUE;
+                bForceEndPage = true;
               case XFA_ItemLayoutProcessorResult_RowFullBreak:
                 goto SuspendAndCreateNewRow;
               case XFA_ItemLayoutProcessorResult_Done:
               default:
                 fContentCurRowY += XFA_ItemLayoutProcessor_InsertPendingItems(
                     pProcessor, m_pCurChildNode);
                 delete pProcessor;
                 pProcessor = nullptr;
             }
           }
           break;
         case XFA_ItemLayoutProcessorStages_Done:
           break;
         default:
           break;
       }
       XFA_ItemLayoutProcessor_GotoNextContainerNode(
-          m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, TRUE);
+          m_pCurChildNode, m_nCurChildNodeStage, m_pFormNode, true);
       if (bAddedItemInRow && eFlowStrategy == XFA_ATTRIBUTEENUM_Tb) {
         break;
       } else {
         continue;
       }
     SuspendAndCreateNewRow:
       if (pProcessor) {
         m_pCurChildPreprocessor = pProcessor;
       }
       break;
     }
     CalculateRowChildPosition(rgCurLineLayoutItems, eFlowStrategy,
                               bContainerHeightAutoSize, bContainerWidthAutoSize,
                               fContentCalculatedWidth, fContentCalculatedHeight,
                               fContentCurRowY, fContentCurRowHeight,
                               fContentWidthLimit, bRootForceTb);
     m_fWidthLimite = fContentCurRowAvailWidth;
     if (bForceEndPage) {
       break;
     }
   }
-  FX_BOOL bRetValue =
-      m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done &&
-      m_PendingNodes.empty();
+  bool bRetValue = m_nCurChildNodeStage == XFA_ItemLayoutProcessorStages_Done &&
+                   m_PendingNodes.empty();
   if (bBreakDone) {
-    bRetValue = FALSE;
+    bRetValue = false;
   }
   XFA_ItemLayoutProcessor_CalculateContainerComponentSizeFromContentSize(
       m_pFormNode, bContainerWidthAutoSize, fContentCalculatedWidth,
       fContainerWidth, bContainerHeightAutoSize, fContentCalculatedHeight,
       fContainerHeight);
   if (fContainerHeight >= XFA_LAYOUT_FLOAT_PERCISION || m_pLayoutItem ||
       bRetValue) {
     if (!m_pLayoutItem) {
       m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
     }
     if (fContainerHeight < 0) {
       fContainerHeight = 0;
     }
     SetCurrentComponentSize(fContainerWidth, fContainerHeight);
     if (bForceEndPage) {
       m_fUsedSize = 0;
     } else {
       m_fUsedSize += m_pLayoutItem->m_sSize.y;
     }
   }
   return bRetValue
              ? XFA_ItemLayoutProcessorResult_Done
              : (bIsManualBreak ? XFA_ItemLayoutProcessorResult_ManualBreak
                                : XFA_ItemLayoutProcessorResult_PageFullBreak);
 }
 
-FX_BOOL CXFA_ItemLayoutProcessor::CalculateRowChildPosition(
-    CFX_ArrayTemplate<CXFA_ContentLayoutItem*>(&rgCurLineLayoutItems)[3],
+bool CXFA_ItemLayoutProcessor::CalculateRowChildPosition(
+    CFX_ArrayTemplate<CXFA_ContentLayoutItem*> (&rgCurLineLayoutItems)[3],
     XFA_ATTRIBUTEENUM eFlowStrategy,
-    FX_BOOL bContainerHeightAutoSize,
-    FX_BOOL bContainerWidthAutoSize,
+    bool bContainerHeightAutoSize,
+    bool bContainerWidthAutoSize,
     FX_FLOAT& fContentCalculatedWidth,
     FX_FLOAT& fContentCalculatedHeight,
     FX_FLOAT& fContentCurRowY,
     FX_FLOAT fContentCurRowHeight,
     FX_FLOAT fContentWidthLimit,
-    FX_BOOL bRootForceTb) {
+    bool bRootForceTb) {
   int32_t nGroupLengths[3] = {0, 0, 0};
   FX_FLOAT fGroupWidths[3] = {0, 0, 0};
   int32_t nTotalLength = 0;
   for (int32_t i = 0; i < 3; i++) {
     nGroupLengths[i] = rgCurLineLayoutItems[i].GetSize();
     for (int32_t c = nGroupLengths[i], j = 0; j < c; j++) {
       nTotalLength++;
       if (XFA_ItemLayoutProcessor_IsTakingSpace(
               rgCurLineLayoutItems[i][j]->m_pFormNode)) {
         fGroupWidths[i] += rgCurLineLayoutItems[i][j]->m_sSize.x;
       }
     }
   }
   if (!nTotalLength) {
     if (bContainerHeightAutoSize) {
       FX_FLOAT fNewHeight = fContentCurRowY;
       if (fContentCalculatedHeight > fNewHeight) {
         fContentCalculatedHeight = fNewHeight;
       }
     }
-    return FALSE;
+    return false;
   }
   if (!m_pLayoutItem) {
     m_pLayoutItem = CreateContentLayoutItem(m_pFormNode);
   }
   if (eFlowStrategy != XFA_ATTRIBUTEENUM_Rl_tb) {
     FX_FLOAT fCurPos;
     fCurPos = 0;
     for (int32_t c = nGroupLengths[0], j = 0; j < c; j++) {
       if (bRootForceTb) {
         FX_FLOAT fAbsoluteX, fAbsoluteY;
@@ skipping 101 matching lines @@
     if (fContentCalculatedWidth < fChildSuppliedWidth) {
       fContentCalculatedWidth = fChildSuppliedWidth;
     }
   }
   if (bContainerHeightAutoSize) {
     FX_FLOAT fChildSuppliedHeight = fContentCurRowY;
     if (fContentCalculatedHeight < fChildSuppliedHeight) {
       fContentCalculatedHeight = fChildSuppliedHeight;
     }
   }
-  return TRUE;
+  return true;
 }
 CXFA_Node* CXFA_ItemLayoutProcessor::GetSubformSetParent(
     CXFA_Node* pSubformSet) {
   if (pSubformSet && pSubformSet->GetElementType() == XFA_Element::SubformSet) {
     CXFA_Node* pParent = pSubformSet->GetNodeItem(XFA_NODEITEM_Parent);
     while (pParent) {
       if (pParent->GetElementType() != XFA_Element::SubformSet) {
         return pParent;
       }
       pParent = pParent->GetNodeItem(XFA_NODEITEM_Parent);
@@ skipping 19 matching lines @@
       FXSYS_round(m_pFormNode->GetMeasure(XFA_ATTRIBUTE_Rotate).GetValue());
   nRotate = XFA_MapRotation(nRotate);
   if (nRotate == 90 || nRotate == 270) {
     FX_FLOAT fTmp = fWidth;
     fWidth = fHeight;
     fHeight = fTmp;
   }
   SetCurrentComponentSize(fWidth, fHeight);
 }
 XFA_ItemLayoutProcessorResult CXFA_ItemLayoutProcessor::DoLayout(
-    FX_BOOL bUseBreakControl,
+    bool bUseBreakControl,
     FX_FLOAT fHeightLimit,
     FX_FLOAT fRealHeight,
     CXFA_LayoutContext* pContext) {
   switch (m_pFormNode->GetElementType()) {
     case XFA_Element::Subform:
     case XFA_Element::Area:
     case XFA_Element::ExclGroup:
     case XFA_Element::SubformSet: {
-      FX_BOOL bRootForceTb = FALSE;
+      bool bRootForceTb = false;
       CXFA_Node* pLayoutNode = GetSubformSetParent(m_pFormNode);
       XFA_ATTRIBUTEENUM eLayoutStrategy =
           XFA_ItemLayoutProcessor_GetLayout(pLayoutNode, bRootForceTb);
       switch (eLayoutStrategy) {
         case XFA_ATTRIBUTEENUM_Tb:
         case XFA_ATTRIBUTEENUM_Lr_tb:
         case XFA_ATTRIBUTEENUM_Rl_tb:
           return DoLayoutFlowedContainer(bUseBreakControl, eLayoutStrategy,
                                          fHeightLimit, fRealHeight, pContext,
                                          bRootForceTb);
@@ skipping 35 matching lines @@
 }
 void CXFA_ItemLayoutProcessor::SetCurrentComponentPos(FX_FLOAT fAbsoluteX,
                                                       FX_FLOAT fAbsoluteY) {
   m_pLayoutItem->m_sPos = CFX_PointF(fAbsoluteX, fAbsoluteY);
 }
 void CXFA_ItemLayoutProcessor::SetCurrentComponentSize(FX_FLOAT fWidth,
                                                        FX_FLOAT fHeight) {
   m_pLayoutItem->m_sSize = CFX_SizeF(fWidth, fHeight);
 }
 
-FX_BOOL CXFA_ItemLayoutProcessor::JudgeLeaderOrTrailerForOccur(
+bool CXFA_ItemLayoutProcessor::JudgeLeaderOrTrailerForOccur(
     CXFA_Node* pFormNode) {
   if (!pFormNode)
-    return FALSE;
+    return false;
 
   CXFA_Node* pTemplate = pFormNode->GetTemplateNode();
   if (!pTemplate)
     pTemplate = pFormNode;
 
   CXFA_Occur NodeOccur(pTemplate->GetFirstChildByClass(XFA_Element::Occur));
   int32_t iMax = NodeOccur.GetMax();
   if (iMax < 0)
-    return TRUE;
+    return true;
 
   int32_t iCount = m_PendingNodesCount[pTemplate];
   if (iCount >= iMax)
-    return FALSE;
+    return false;
 
   m_PendingNodesCount[pTemplate] = iCount + 1;
-  return TRUE;
+  return true;
 }