Remove FX_BOOL from xfa.

xfa/fxfa/app/xfa_textlayout.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/app/xfa_textlayout.h"
 
 #include <algorithm>
 
 #include "core/fxcrt/fx_ext.h"
 #include "xfa/fde/cfde_path.h"
 #include "xfa/fde/css/fde_csscache.h"
 #include "xfa/fde/css/fde_cssstyleselector.h"
 #include "xfa/fde/fde_gedevice.h"
 #include "xfa/fde/fde_object.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fxfa/app/xfa_ffwidgetacc.h"
 #include "xfa/fxfa/parser/cxfa_measurement.h"
 #include "xfa/fxfa/xfa_ffapp.h"
 #include "xfa/fxfa/xfa_ffdoc.h"
 #include "xfa/fxfa/xfa_fontmgr.h"
 
 CXFA_CSSTagProvider::CXFA_CSSTagProvider()
-    : m_bTagAvailable(FALSE), m_bContent(FALSE) {}
+    : m_bTagAvailable(false), m_bContent(false) {}
 
 CXFA_CSSTagProvider::~CXFA_CSSTagProvider() {}
 
 XFA_TextPiece::XFA_TextPiece()
     : pszText(nullptr), pFont(nullptr), pLinkData(nullptr) {}
 
 XFA_TextPiece::~XFA_TextPiece() {
   if (pLinkData)
     pLinkData->Release();
 }
@@ skipping 68 matching lines @@
     m_pSelector->SetDefFontSize(fFontSize);
   }
   if (!m_pUASheet) {
     m_pUASheet = LoadDefaultSheetStyle();
     m_pSelector->SetStyleSheet(FDE_CSSSTYLESHEETGROUP_UserAgent, m_pUASheet);
     m_pSelector->UpdateStyleIndex(FDE_CSSMEDIATYPE_ALL);
   }
 }
 
 CXFA_LoaderContext::CXFA_LoaderContext()
-    : m_bSaveLineHeight(FALSE),
+    : m_bSaveLineHeight(false),
       m_fWidth(0),
       m_fHeight(0),
       m_fLastPos(0),
       m_fStartLineOffset(0),
       m_iChar(0),
       m_iTotalLines(-1),
       m_pXMLNode(nullptr),
       m_pNode(nullptr),
       m_pParentStyle(nullptr),
       m_dwFlags(0) {}
@@ skipping 208 matching lines @@
     pXMLElement->GetLocalTagName(wsName);
     tagProvider.SetTagNameObj(wsName);
     tagProvider.m_bTagAvailable = TagValidate(wsName);
 
     CFX_WideString wsValue;
     pXMLElement->GetString(L"style", wsValue);
     if (!wsValue.IsEmpty()) {
       tagProvider.SetAttribute(L"style", wsValue);
     }
   } else if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
-    tagProvider.m_bTagAvailable = TRUE;
-    tagProvider.m_bContent = TRUE;
+    tagProvider.m_bTagAvailable = true;
+    tagProvider.m_bContent = true;
   }
 }
 
 int32_t CXFA_TextParser::GetVAlign(CXFA_TextProvider* pTextProvider) const {
   CXFA_Para para = pTextProvider->GetParaNode();
   return para ? para.GetVerticalAlign() : XFA_ATTRIBUTEENUM_Top;
 }
 
 FX_FLOAT CXFA_TextParser::GetTabInterval(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"tab-interval"), wsValue))
     return CXFA_Measurement(wsValue.AsStringC()).ToUnit(XFA_UNIT_Pt);
   return 36;
 }
 
 int32_t CXFA_TextParser::CountTabs(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"xfa-tab-count"), wsValue))
     return wsValue.GetInteger();
   return 0;
 }
 
-FX_BOOL CXFA_TextParser::IsSpaceRun(IFDE_CSSComputedStyle* pStyle) const {
+bool CXFA_TextParser::IsSpaceRun(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"xfa-spacerun"), wsValue)) {
     wsValue.MakeLower();
     return wsValue == FX_WSTRC(L"yes");
   }
-  return FALSE;
+  return false;
 }
 CFGAS_GEFont* CXFA_TextParser::GetFont(CXFA_TextProvider* pTextProvider,
                                        IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideStringC wsFamily = FX_WSTRC(L"Courier");
   uint32_t dwStyle = 0;
   CXFA_Font font = pTextProvider->GetFontNode();
   if (font) {
     font.GetTypeface(wsFamily);
     if (font.IsBold()) {
       dwStyle |= FX_FONTSTYLE_Bold;
@@ skipping 128 matching lines @@
     if (pParaStyle->GetVerticalAlign() == FDE_CSSVERTICALALIGN_Number) {
       return pParaStyle->GetNumberVerticalAlign();
     }
   } else if (CXFA_Font font = pTextProvider->GetFontNode()) {
     return font.GetBaselineShift();
   }
   return 0;
 }
 FX_FLOAT CXFA_TextParser::GetLineHeight(CXFA_TextProvider* pTextProvider,
                                         IFDE_CSSComputedStyle* pStyle,
-                                        FX_BOOL bFirst,
+                                        bool bFirst,
                                         FX_FLOAT fVerScale) const {
   FX_FLOAT fLineHeight = 0;
   if (pStyle) {
     fLineHeight = pStyle->GetParagraphStyles()->GetLineHeight();
   } else if (CXFA_Para para = pTextProvider->GetParaNode()) {
     fLineHeight = para.GetLineHeight();
   }
   if (bFirst) {
     FX_FLOAT fFontSize = GetFontSize(pTextProvider, pStyle);
     if (fLineHeight < 0.1f) {
       fLineHeight = fFontSize;
     } else {
       fLineHeight = std::min(fLineHeight, fFontSize);
     }
   } else if (fLineHeight < 0.1f) {
     fLineHeight = GetFontSize(pTextProvider, pStyle) * 1.2f;
   }
   fLineHeight *= fVerScale;
   return fLineHeight;
 }
-FX_BOOL CXFA_TextParser::GetEmbbedObj(CXFA_TextProvider* pTextProvider,
-                                      CFDE_XMLNode* pXMLNode,
-                                      CFX_WideString& wsValue) {
+bool CXFA_TextParser::GetEmbbedObj(CXFA_TextProvider* pTextProvider,
+                                   CFDE_XMLNode* pXMLNode,
+                                   CFX_WideString& wsValue) {
   wsValue.clear();
   if (!pXMLNode) {
-    return FALSE;
+    return false;
   }
-  FX_BOOL bRet = FALSE;
+  bool bRet = false;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
     CFDE_XMLElement* pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     CFX_WideString wsAttr;
     pElement->GetString(L"xfa:embed", wsAttr);
     if (wsAttr.IsEmpty()) {
-      return FALSE;
+      return false;
     }
     if (wsAttr.GetAt(0) == L'#') {
       wsAttr.Delete(0);
     }
     CFX_WideString ws;
     pElement->GetString(L"xfa:embedType", ws);
     if (ws.IsEmpty()) {
       ws = L"som";
     } else {
       ws.MakeLower();
     }
-    FX_BOOL bURI = (ws == FX_WSTRC(L"uri"));
+    bool bURI = (ws == FX_WSTRC(L"uri"));
     if (!bURI && ws != FX_WSTRC(L"som")) {
-      return FALSE;
+      return false;
     }
     ws.clear();
     pElement->GetString(L"xfa:embedMode", ws);
     if (ws.IsEmpty()) {
       ws = L"formatted";
     } else {
       ws.MakeLower();
     }
-    FX_BOOL bRaw = (ws == FX_WSTRC(L"raw"));
+    bool bRaw = (ws == FX_WSTRC(L"raw"));
     if (!bRaw && ws != FX_WSTRC(L"formatted")) {
-      return FALSE;
+      return false;
     }
     bRet = pTextProvider->GetEmbbedObj(bURI, bRaw, wsAttr, wsValue);
   }
   return bRet;
 }
 CXFA_TextParseContext* CXFA_TextParser::GetParseContextFromMap(
     CFDE_XMLNode* pXMLNode) {
   return (CXFA_TextParseContext*)m_mapXMLNodeToParseContext.GetValueAt(
       pXMLNode);
 }
 enum XFA_TABSTOPSSTATUS {
   XFA_TABSTOPSSTATUS_Error,
   XFA_TABSTOPSSTATUS_EOS,
   XFA_TABSTOPSSTATUS_None,
   XFA_TABSTOPSSTATUS_Alignment,
   XFA_TABSTOPSSTATUS_StartLeader,
   XFA_TABSTOPSSTATUS_Leader,
   XFA_TABSTOPSSTATUS_Location,
 };
-FX_BOOL CXFA_TextParser::GetTabstops(
-    IFDE_CSSComputedStyle* pStyle,
-    CXFA_TextTabstopsContext* pTabstopContext) {
+bool CXFA_TextParser::GetTabstops(IFDE_CSSComputedStyle* pStyle,
+                                  CXFA_TextTabstopsContext* pTabstopContext) {
   if (!pStyle || !pTabstopContext) {
-    return FALSE;
+    return false;
   }
   CFX_WideString wsValue;
   if (!pStyle->GetCustomStyle(FX_WSTRC(L"xfa-tab-stops"), wsValue) &&
       !pStyle->GetCustomStyle(FX_WSTRC(L"tab-stops"), wsValue)) {
-    return FALSE;
+    return false;
   }
   int32_t iLength = wsValue.GetLength();
   const FX_WCHAR* pTabStops = wsValue.c_str();
   int32_t iCur = 0;
   int32_t iLast = 0;
   CFX_WideString wsAlign;
   XFA_TABSTOPSSTATUS eStatus = XFA_TABSTOPSSTATUS_None;
   FX_WCHAR ch;
   while (iCur < iLength) {
     ch = pTabStops[iCur];
@@ skipping 57 matching lines @@
       default:
         break;
     }
   }
   if (!wsAlign.IsEmpty()) {
     uint32_t dwHashCode = FX_HashCode_GetW(wsAlign.AsStringC(), true);
     CXFA_Measurement ms(CFX_WideStringC(pTabStops + iLast, iCur - iLast));
     FX_FLOAT fPos = ms.ToUnit(XFA_UNIT_Pt);
     pTabstopContext->Append(dwHashCode, fPos);
   }
-  return TRUE;
+  return true;
 }
 
 CXFA_TextLayout::CXFA_TextLayout(CXFA_TextProvider* pTextProvider)
-    : m_bHasBlock(FALSE),
+    : m_bHasBlock(false),
       m_pTextProvider(pTextProvider),
       m_pTextDataNode(nullptr),
-      m_bRichText(FALSE),
+      m_bRichText(false),
       m_iLines(0),
       m_fMaxWidth(0),
-      m_bBlockContinue(TRUE) {
+      m_bBlockContinue(true) {
   ASSERT(m_pTextProvider);
 }
 
 CXFA_TextLayout::~CXFA_TextLayout() {
   m_textParser.Reset();
   Unload();
 }
 
 void CXFA_TextLayout::Unload() {
   for (int32_t i = 0; i < m_pieceLines.GetSize(); i++) {
@@ skipping 46 matching lines @@
         pXMLElement->GetLocalTagName(wsTag);
         if (wsTag == FX_WSTRC(L"body") || wsTag == FX_WSTRC(L"html")) {
           pXMLContainer = pXMLChild;
           break;
         }
       }
     }
   }
   return pXMLContainer;
 }
-CFX_RTFBreak* CXFA_TextLayout::CreateBreak(FX_BOOL bDefault) {
+CFX_RTFBreak* CXFA_TextLayout::CreateBreak(bool bDefault) {
   uint32_t dwStyle = FX_RTFLAYOUTSTYLE_ExpandTab;
   if (!bDefault) {
     dwStyle |= FX_RTFLAYOUTSTYLE_Pagination;
   }
   CFX_RTFBreak* pBreak = new CFX_RTFBreak(0);
   pBreak->SetLayoutStyles(dwStyle);
   pBreak->SetLineBreakChar(L'\n');
   pBreak->SetLineBreakTolerance(1);
   pBreak->SetFont(m_textParser.GetFont(m_pTextProvider, nullptr));
   pBreak->SetFontSize(m_textParser.GetFontSize(m_pTextProvider, nullptr));
@@ skipping 145 matching lines @@
   return wsText.GetLength();
 }
 FX_FLOAT CXFA_TextLayout::GetLayoutHeight() {
   if (!m_pLoader) {
     return 0;
   }
   int32_t iCount = m_pLoader->m_lineHeights.GetSize();
   if (iCount == 0 && m_pLoader->m_fWidth > 0) {
     CFX_SizeF szMax(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
     CFX_SizeF szDef;
-    m_pLoader->m_bSaveLineHeight = TRUE;
+    m_pLoader->m_bSaveLineHeight = true;
     m_pLoader->m_fLastPos = 0;
     CalcSize(szMax, szMax, szDef);
-    m_pLoader->m_bSaveLineHeight = FALSE;
+    m_pLoader->m_bSaveLineHeight = false;
     return szDef.y;
   }
   FX_FLOAT fHeight = m_pLoader->m_fHeight;
   if (fHeight < 0.1f) {
     fHeight = 0;
     for (int32_t i = 0; i < iCount; i++) {
       fHeight += m_pLoader->m_lineHeights.ElementAt(i);
     }
   }
   return fHeight;
 }
 FX_FLOAT CXFA_TextLayout::StartLayout(FX_FLOAT fWidth) {
   if (!m_pLoader)
     m_pLoader.reset(new CXFA_LoaderContext);
 
   if (fWidth < 0 || (m_pLoader->m_fWidth > -1 &&
                      FXSYS_fabs(fWidth - m_pLoader->m_fWidth) > 0)) {
     m_pLoader->m_lineHeights.RemoveAll();
     m_Blocks.RemoveAll();
     Unload();
     m_pLoader->m_fStartLineOffset = 0;
   }
   m_pLoader->m_fWidth = fWidth;
   if (fWidth < 0) {
     CFX_SizeF szMax;
     CFX_SizeF szDef;
-    m_pLoader->m_bSaveLineHeight = TRUE;
+    m_pLoader->m_bSaveLineHeight = true;
     m_pLoader->m_fLastPos = 0;
     CalcSize(szMax, szMax, szDef);
-    m_pLoader->m_bSaveLineHeight = FALSE;
+    m_pLoader->m_bSaveLineHeight = false;
     fWidth = szDef.x;
   }
   return fWidth;
 }
-FX_BOOL CXFA_TextLayout::DoLayout(int32_t iBlockIndex,
-                                  FX_FLOAT& fCalcHeight,
-                                  FX_FLOAT fContentAreaHeight,
-                                  FX_FLOAT fTextHeight) {
+bool CXFA_TextLayout::DoLayout(int32_t iBlockIndex,
+                               FX_FLOAT& fCalcHeight,
+                               FX_FLOAT fContentAreaHeight,
+                               FX_FLOAT fTextHeight) {
   if (!m_pLoader) {
-    return FALSE;
+    return false;
   }
   int32_t iBlockCount = m_Blocks.GetSize();
   FX_FLOAT fHeight = fTextHeight;
   if (fHeight < 0) {
     fHeight = GetLayoutHeight();
   }
   m_pLoader->m_fHeight = fHeight;
   if (fContentAreaHeight < 0) {
-    return FALSE;
+    return false;
   }
-  m_bHasBlock = TRUE;
+  m_bHasBlock = true;
   if (iBlockCount == 0 && fHeight > 0) {
     fHeight = fTextHeight - GetLayoutHeight();
     if (fHeight > 0) {
       int32_t iAlign = m_textParser.GetVAlign(m_pTextProvider);
       if (iAlign == XFA_ATTRIBUTEENUM_Middle) {
         fHeight /= 2.0f;
       } else if (iAlign != XFA_ATTRIBUTEENUM_Bottom) {
         fHeight = 0;
       }
       m_pLoader->m_fStartLineOffset = fHeight;
@@ skipping 13 matching lines @@
         fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
       }
     }
   }
   int32_t iCount = m_pLoader->m_lineHeights.GetSize();
   int32_t i = 0;
   for (i = iLineIndex; i < iCount; i++) {
     FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
     if ((i == iLineIndex) && (fLineHeight - fContentAreaHeight > 0.001)) {
       fCalcHeight = 0;
-      return TRUE;
+      return true;
     }
     if (fLinePos + fLineHeight - fContentAreaHeight > 0.001) {
       if (iBlockCount >= (iBlockIndex + 1) * 2) {
         m_Blocks.SetAt(iBlockIndex * 2, iLineIndex);
         m_Blocks.SetAt(iBlockIndex * 2 + 1, i - iLineIndex);
       } else {
         m_Blocks.Add(iLineIndex);
         m_Blocks.Add(i - iLineIndex);
       }
       if (i == iLineIndex) {
         if (fCalcHeight <= fLinePos) {
           if (m_pLoader->m_BlocksHeight.GetSize() > iBlockIndex * 2 &&
               (m_pLoader->m_BlocksHeight.GetAt(iBlockIndex * 2) ==
                iBlockIndex)) {
             m_pLoader->m_BlocksHeight.SetAt(iBlockIndex * 2 + 1, fCalcHeight);
           } else {
             m_pLoader->m_BlocksHeight.Add((FX_FLOAT)iBlockIndex);
             m_pLoader->m_BlocksHeight.Add(fCalcHeight);
           }
         }
-        return TRUE;
+        return true;
       }
       fCalcHeight = fLinePos;
-      return TRUE;
+      return true;
     }
     fLinePos += fLineHeight;
   }
-  return FALSE;
+  return false;
 }
 int32_t CXFA_TextLayout::CountBlocks() const {
   int32_t iCount = m_Blocks.GetSize() / 2;
   return iCount > 0 ? iCount : 1;
 }
 
-FX_BOOL CXFA_TextLayout::CalcSize(const CFX_SizeF& minSize,
-                                  const CFX_SizeF& maxSize,
-                                  CFX_SizeF& defaultSize) {
+bool CXFA_TextLayout::CalcSize(const CFX_SizeF& minSize,
+                               const CFX_SizeF& maxSize,
+                               CFX_SizeF& defaultSize) {
   defaultSize.x = maxSize.x;
   if (defaultSize.x < 1)
     defaultSize.x = 0xFFFF;
 
-  m_pBreak.reset(CreateBreak(FALSE));
+  m_pBreak.reset(CreateBreak(false));
   FX_FLOAT fLinePos = 0;
   m_iLines = 0;
   m_fMaxWidth = 0;
-  Loader(defaultSize, fLinePos, FALSE);
+  Loader(defaultSize, fLinePos, false);
   if (fLinePos < 0.1f)
     fLinePos = m_textParser.GetFontSize(m_pTextProvider, nullptr);
 
   m_pTabstopContext.reset();
   defaultSize = CFX_SizeF(m_fMaxWidth, fLinePos);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_TextLayout::Layout(const CFX_SizeF& size, FX_FLOAT* fHeight) {
+bool CXFA_TextLayout::Layout(const CFX_SizeF& size, FX_FLOAT* fHeight) {
   if (size.x < 1)
-    return FALSE;
+    return false;
 
   Unload();
-  m_pBreak.reset(CreateBreak(TRUE));
+  m_pBreak.reset(CreateBreak(true));
   if (m_pLoader) {
     m_pLoader->m_iTotalLines = -1;
     m_pLoader->m_iChar = 0;
   }
   m_iLines = 0;
   FX_FLOAT fLinePos = 0;
-  Loader(size, fLinePos, TRUE);
+  Loader(size, fLinePos, true);
   UpdateAlign(size.y, fLinePos);
   m_pTabstopContext.reset();
   if (fHeight)
     *fHeight = fLinePos;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CXFA_TextLayout::Layout(int32_t iBlock) {
+bool CXFA_TextLayout::Layout(int32_t iBlock) {
   if (!m_pLoader || iBlock < 0 || iBlock >= CountBlocks())
-    return FALSE;
+    return false;
   if (m_pLoader->m_fWidth < 1)
-    return FALSE;
+    return false;
 
   m_pLoader->m_iTotalLines = -1;
   m_iLines = 0;
   FX_FLOAT fLinePos = 0;
   CXFA_Node* pNode = nullptr;
   CFX_SizeF szText(m_pLoader->m_fWidth, m_pLoader->m_fHeight);
   int32_t iCount = m_Blocks.GetSize();
   int32_t iBlocksHeightCount = m_pLoader->m_BlocksHeight.GetSize();
   iBlocksHeightCount /= 2;
   if (iBlock < iBlocksHeightCount)
-    return TRUE;
+    return true;
   if (iBlock == iBlocksHeightCount) {
     Unload();
-    m_pBreak.reset(CreateBreak(TRUE));
+    m_pBreak.reset(CreateBreak(true));
     fLinePos = m_pLoader->m_fStartLineOffset;
     for (int32_t i = 0; i < iBlocksHeightCount; i++) {
       fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
     }
     m_pLoader->m_iChar = 0;
     if (iCount > 1)
       m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock * 2 + 1);
-    Loader(szText, fLinePos, TRUE);
+    Loader(szText, fLinePos, true);
     if (iCount == 0 && m_pLoader->m_fStartLineOffset < 0.1f)
       UpdateAlign(szText.y, fLinePos);
   } else if (m_pTextDataNode) {
     iBlock *= 2;
     if (iBlock < iCount - 2)
       m_pLoader->m_iTotalLines = m_Blocks.ElementAt(iBlock + 1);
     m_pBreak->Reset();
     if (m_bRichText) {
       CFDE_XMLNode* pContainerNode = GetXMLContainerNode();
       if (!pContainerNode) {
-        return TRUE;
+        return true;
       }
       CFDE_XMLNode* pXMLNode = m_pLoader->m_pXMLNode;
       if (!pXMLNode)
-        return TRUE;
+        return true;
       CFDE_XMLNode* pSaveXMLNode = m_pLoader->m_pXMLNode;
       for (; pXMLNode;
            pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
         if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle,
-                          TRUE)) {
+                          true)) {
           break;
         }
       }
       while (!pXMLNode) {
         pXMLNode = pSaveXMLNode->GetNodeItem(CFDE_XMLNode::Parent);
         if (pXMLNode == pContainerNode)
           break;
         if (!LoadRichText(pXMLNode, szText, fLinePos, m_pLoader->m_pParentStyle,
-                          TRUE, nullptr, FALSE)) {
+                          true, nullptr, false)) {
           break;
         }
         pSaveXMLNode = pXMLNode;
         pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
         if (!pXMLNode)
           continue;
         for (; pXMLNode;
              pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
           if (!LoadRichText(pXMLNode, szText, fLinePos,
-                            m_pLoader->m_pParentStyle, TRUE)) {
+                            m_pLoader->m_pParentStyle, true)) {
             break;
           }
         }
       }
     } else {
       pNode = m_pLoader->m_pNode;
       if (!pNode)
-        return TRUE;
-      LoadText(pNode, szText, fLinePos, TRUE);
+        return true;
+      LoadText(pNode, szText, fLinePos, true);
     }
   }
   if (iBlock == iCount) {
     m_pTabstopContext.reset();
     m_pLoader.reset();
   }
-  return TRUE;
+  return true;
 }
 void CXFA_TextLayout::ItemBlocks(const CFX_RectF& rtText, int32_t iBlockIndex) {
   if (!m_pLoader) {
     return;
   }
   int32_t iCountHeight = m_pLoader->m_lineHeights.GetSize();
   if (iCountHeight == 0) {
     return;
   }
-  FX_BOOL bEndItem = TRUE;
+  bool bEndItem = true;
   int32_t iBlockCount = m_Blocks.GetSize();
   FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
   int32_t iLineIndex = 0;
   if (iBlockIndex > 0) {
     int32_t iBlockHeightCount = m_pLoader->m_BlocksHeight.GetSize();
     iBlockHeightCount /= 2;
     if (iBlockHeightCount >= iBlockIndex) {
       for (int32_t i = 0; i < iBlockIndex; i++) {
         fLinePos -= m_pLoader->m_BlocksHeight.ElementAt(i * 2 + 1);
       }
     } else {
       fLinePos = 0;
     }
     iLineIndex = m_Blocks.ElementAt(iBlockCount - 1) +
                  m_Blocks.ElementAt(iBlockCount - 2);
   }
   int32_t i = 0;
   for (i = iLineIndex; i < iCountHeight; i++) {
     FX_FLOAT fLineHeight = m_pLoader->m_lineHeights.ElementAt(i);
     if (fLinePos + fLineHeight - rtText.height > 0.001) {
       m_Blocks.Add(iLineIndex);
       m_Blocks.Add(i - iLineIndex);
-      bEndItem = FALSE;
+      bEndItem = false;
       break;
     }
     fLinePos += fLineHeight;
   }
   if (iCountHeight > 0 && (i - iLineIndex) > 0 && bEndItem) {
     m_Blocks.Add(iLineIndex);
     m_Blocks.Add(i - iLineIndex);
   }
 }
-FX_BOOL CXFA_TextLayout::DrawString(CFX_RenderDevice* pFxDevice,
-                                    const CFX_Matrix& tmDoc2Device,
-                                    const CFX_RectF& rtClip,
-                                    int32_t iBlock) {
+bool CXFA_TextLayout::DrawString(CFX_RenderDevice* pFxDevice,
+                                 const CFX_Matrix& tmDoc2Device,
+                                 const CFX_RectF& rtClip,
+                                 int32_t iBlock) {
   if (!pFxDevice)
-    return FALSE;
+    return false;
 
   std::unique_ptr<CFDE_RenderDevice> pDevice(
-      new CFDE_RenderDevice(pFxDevice, FALSE));
+      new CFDE_RenderDevice(pFxDevice, false));
   pDevice->SaveState();
   pDevice->SetClipRect(rtClip);
 
   std::unique_ptr<CFDE_Brush> pSolidBrush(new CFDE_Brush);
   std::unique_ptr<CFDE_Pen> pPen(new CFDE_Pen);
   if (m_pieceLines.GetSize() == 0) {
     int32_t iBlockCount = CountBlocks();
     for (int32_t i = 0; i < iBlockCount; i++) {
       Layout(i);
     }
@@ skipping 58 matching lines @@
   for (int32_t i = 0; i < iCount; i++) {
     CXFA_PieceLine* pPieceLine = m_pieceLines.GetAt(i);
     int32_t iPieces = pPieceLine->m_textPieces.GetSize();
     for (int32_t j = 0; j < iPieces; j++) {
       XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(j);
       CFX_RectF& rect = pPiece->rtPiece;
       rect.top += fHeight;
     }
   }
 }
-FX_BOOL CXFA_TextLayout::Loader(const CFX_SizeF& szText,
-                                FX_FLOAT& fLinePos,
-                                FX_BOOL bSavePieces) {
+bool CXFA_TextLayout::Loader(const CFX_SizeF& szText,
+                             FX_FLOAT& fLinePos,
+                             bool bSavePieces) {
   if (!m_pAllocator) {
     m_pAllocator = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 256, 0);
   }
   GetTextDataNode();
   if (!m_pTextDataNode)
-    return TRUE;
+    return true;
 
   if (m_bRichText) {
     CFDE_XMLNode* pXMLContainer = GetXMLContainerNode();
     if (pXMLContainer) {
       if (!m_textParser.IsParsed()) {
         m_textParser.DoParse(pXMLContainer, m_pTextProvider);
       }
       IFDE_CSSComputedStyle* pRootStyle =
           m_textParser.CreateRootStyle(m_pTextProvider);
       LoadRichText(pXMLContainer, szText, fLinePos, pRootStyle, bSavePieces);
       pRootStyle->Release();
     }
   } else {
     LoadText(m_pTextDataNode, szText, fLinePos, bSavePieces);
   }
-  return TRUE;
+  return true;
 }
 void CXFA_TextLayout::LoadText(CXFA_Node* pNode,
                                const CFX_SizeF& szText,
                                FX_FLOAT& fLinePos,
-                               FX_BOOL bSavePieces) {
+                               bool bSavePieces) {
   InitBreak(szText.x);
   CXFA_Para para = m_pTextProvider->GetParaNode();
   FX_FLOAT fSpaceAbove = 0;
   if (para) {
     fSpaceAbove = para.GetSpaceAbove();
     if (fSpaceAbove < 0.1f) {
       fSpaceAbove = 0;
     }
     int32_t verAlign = para.GetVerticalAlign();
     switch (verAlign) {
       case XFA_ATTRIBUTEENUM_Top:
       case XFA_ATTRIBUTEENUM_Middle:
       case XFA_ATTRIBUTEENUM_Bottom: {
         fLinePos += fSpaceAbove;
         break;
       }
     }
   }
   CFX_WideString wsText = pNode->GetContent();
   wsText.TrimRight(L" ");
-  FX_BOOL bRet = AppendChar(wsText, fLinePos, fSpaceAbove, bSavePieces);
+  bool bRet = AppendChar(wsText, fLinePos, fSpaceAbove, bSavePieces);
   if (bRet && m_pLoader) {
     m_pLoader->m_pNode = pNode;
   } else {
     EndBreak(FX_RTFBREAK_ParagraphBreak, fLinePos, bSavePieces);
   }
 }
-FX_BOOL CXFA_TextLayout::LoadRichText(CFDE_XMLNode* pXMLNode,
-                                      const CFX_SizeF& szText,
-                                      FX_FLOAT& fLinePos,
-                                      IFDE_CSSComputedStyle* pParentStyle,
-                                      FX_BOOL bSavePieces,
-                                      CXFA_LinkUserData* pLinkData,
-                                      FX_BOOL bEndBreak,
-                                      FX_BOOL bIsOl,
-                                      int32_t iLiCount) {
+bool CXFA_TextLayout::LoadRichText(CFDE_XMLNode* pXMLNode,
+                                   const CFX_SizeF& szText,
+                                   FX_FLOAT& fLinePos,
+                                   IFDE_CSSComputedStyle* pParentStyle,
+                                   bool bSavePieces,
+                                   CXFA_LinkUserData* pLinkData,
+                                   bool bEndBreak,
+                                   bool bIsOl,
+                                   int32_t iLiCount) {
   if (!pXMLNode) {
-    return FALSE;
+    return false;
   }
   CXFA_TextParseContext* pContext =
       m_textParser.GetParseContextFromMap(pXMLNode);
   FDE_CSSDISPLAY eDisplay = FDE_CSSDISPLAY_None;
-  FX_BOOL bContentNode = FALSE;
+  bool bContentNode = false;
   FX_FLOAT fSpaceBelow = 0;
   IFDE_CSSComputedStyle* pStyle = nullptr;
   CFX_WideString wsName;
   if (bEndBreak) {
-    FX_BOOL bCurOl = FALSE;
-    FX_BOOL bCurLi = FALSE;
+    bool bCurOl = false;
+    bool bCurLi = false;
     CFDE_XMLElement* pElement = nullptr;
     if (pContext) {
       if (m_bBlockContinue ||
           (m_pLoader && pXMLNode == m_pLoader->m_pXMLNode)) {
-        m_bBlockContinue = TRUE;
+        m_bBlockContinue = true;
       }
       if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
-        bContentNode = TRUE;
+        bContentNode = true;
       } else if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
         pElement = static_cast<CFDE_XMLElement*>(pXMLNode);
         pElement->GetLocalTagName(wsName);
       }
       if (wsName == FX_WSTRC(L"ol")) {
-        bIsOl = TRUE;
-        bCurOl = TRUE;
+        bIsOl = true;
+        bCurOl = true;
       }
-      if (m_bBlockContinue || bContentNode == FALSE) {
+      if (m_bBlockContinue || bContentNode == false) {
         eDisplay = pContext->GetDisplay();
         if (eDisplay != FDE_CSSDISPLAY_Block &&
             eDisplay != FDE_CSSDISPLAY_Inline &&
             eDisplay != FDE_CSSDISPLAY_ListItem) {
-          return TRUE;
+          return true;
         }
         pStyle = m_textParser.ComputeStyle(pXMLNode, pParentStyle);
         InitBreak(bContentNode ? pParentStyle : pStyle, eDisplay, szText.x,
                   pXMLNode, pParentStyle);
         if ((eDisplay == FDE_CSSDISPLAY_Block ||
              eDisplay == FDE_CSSDISPLAY_ListItem) &&
             pStyle &&
             (wsName.IsEmpty() ||
              (wsName != FX_WSTRC(L"body") && wsName != FX_WSTRC(L"html") &&
               wsName != FX_WSTRC(L"ol") && wsName != FX_WSTRC(L"ul")))) {
@@ skipping 10 matching lines @@
           pElement->GetString(L"href", wsLinkContent);
           if (!wsLinkContent.IsEmpty()) {
             pLinkData = FXTARGET_NewWith(m_pAllocator.get()) CXFA_LinkUserData(
                 m_pAllocator.get(),
                 wsLinkContent.GetBuffer(wsLinkContent.GetLength()));
             wsLinkContent.ReleaseBuffer(wsLinkContent.GetLength());
           }
         }
         int32_t iTabCount =
             m_textParser.CountTabs(bContentNode ? pParentStyle : pStyle);
-        FX_BOOL bSpaceRun =
+        bool bSpaceRun =
             m_textParser.IsSpaceRun(bContentNode ? pParentStyle : pStyle);
         CFX_WideString wsText;
         if (bContentNode && iTabCount == 0) {
           static_cast<CFDE_XMLText*>(pXMLNode)->GetText(wsText);
         } else if (wsName == FX_WSTRC(L"br")) {
           wsText = L'\n';
         } else if (wsName == FX_WSTRC(L"li")) {
-          bCurLi = TRUE;
+          bCurLi = true;
           if (bIsOl) {
             wsText.Format(L"%d.  ", iLiCount);
           } else {
             wsText = 0x00B7 + FX_WSTRC(L"  ");
           }
         } else if (!bContentNode) {
           if (iTabCount > 0) {
             while (iTabCount-- > 0)
               wsText += L'\t';
           } else {
@@ skipping 36 matching lines @@
             if (m_pLoader) {
               m_pLoader->m_dwFlags &= ~XFA_LOADERCNTXTFLG_FILTERSPACE;
             }
             if (IsEnd(bSavePieces)) {
               if (m_pLoader && m_pLoader->m_iTotalLines > -1) {
                 m_pLoader->m_pXMLNode = pXMLNode;
                 m_pLoader->m_pParentStyle = pParentStyle;
               }
               if (pStyle)
                 pStyle->Release();
-              return FALSE;
+              return false;
             }
-            return TRUE;
+            return true;
           }
         }
       }
     }
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     for (CFDE_XMLNode* pChildNode =
              pXMLNode->GetNodeItem(CFDE_XMLNode::FirstChild);
          pChildNode;
          pChildNode = pChildNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
       if (bCurOl) {
         iLiCount++;
       }
       ret = LoadRichText(pChildNode, szText, fLinePos,
                          pContext ? pStyle : pParentStyle, bSavePieces,
-                         pLinkData, TRUE, bIsOl, iLiCount);
-      if (ret == FALSE) {
-        return FALSE;
+                         pLinkData, true, bIsOl, iLiCount);
+      if (ret == false) {
+        return false;
       }
     }
     if (m_pLoader) {
       if (FDE_CSSDISPLAY_Block == eDisplay) {
         m_pLoader->m_dwFlags |= XFA_LOADERCNTXTFLG_FILTERSPACE;
       }
     }
     if (bCurLi) {
       EndBreak(FX_RTFBREAK_LineBreak, fLinePos, bSavePieces);
     }
@@ skipping 22 matching lines @@
       }
       if (IsEnd(bSavePieces)) {
         if (pStyle) {
           pStyle->Release();
         }
         if (m_pLoader && m_pLoader->m_iTotalLines > -1) {
           m_pLoader->m_pXMLNode =
               pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling);
           m_pLoader->m_pParentStyle = pParentStyle;
         }
-        return FALSE;
+        return false;
       }
     }
   }
   if (pStyle)
     pStyle->Release();
-  return TRUE;
+  return true;
 }
-FX_BOOL CXFA_TextLayout::AppendChar(const CFX_WideString& wsText,
-                                    FX_FLOAT& fLinePos,
-                                    FX_FLOAT fSpaceAbove,
-                                    FX_BOOL bSavePieces) {
+bool CXFA_TextLayout::AppendChar(const CFX_WideString& wsText,
+                                 FX_FLOAT& fLinePos,
+                                 FX_FLOAT fSpaceAbove,
+                                 bool bSavePieces) {
   uint32_t dwStatus = 0;
   int32_t iChar = 0;
   if (m_pLoader) {
     iChar = m_pLoader->m_iChar;
   }
   int32_t iLength = wsText.GetLength();
   for (int32_t i = iChar; i < iLength; i++) {
     FX_WCHAR wch = wsText.GetAt(i);
     if (wch == 0xA0) {
       wch = 0x20;
     }
     if ((dwStatus = m_pBreak->AppendChar(wch)) > FX_RTFBREAK_PieceBreak) {
       AppendTextLine(dwStatus, fLinePos, bSavePieces);
       if (IsEnd(bSavePieces)) {
         if (m_pLoader)
           m_pLoader->m_iChar = i;
-        return TRUE;
+        return true;
       }
       if (dwStatus == FX_RTFBREAK_ParagraphBreak && m_bRichText) {
         fLinePos += fSpaceAbove;
       }
     }
   }
   if (m_pLoader) {
     m_pLoader->m_iChar = 0;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXFA_TextLayout::IsEnd(FX_BOOL bSavePieces) {
+bool CXFA_TextLayout::IsEnd(bool bSavePieces) {
   if (!bSavePieces) {
-    return FALSE;
+    return false;
   }
   if (m_pLoader && m_pLoader->m_iTotalLines > 0) {
     return m_iLines >= m_pLoader->m_iTotalLines;
   }
-  return FALSE;
+  return false;
 }
 void CXFA_TextLayout::ProcessText(CFX_WideString& wsText) {
   int32_t iLen = wsText.GetLength();
   if (iLen == 0) {
     return;
   }
   FX_WCHAR* psz = wsText.GetBuffer(iLen);
   int32_t iTrimLeft = 0;
   FX_WCHAR wch = 0, wPrev = 0;
   for (int32_t i = 0; i < iLen; i++) {
     wch = psz[i];
     if (wch < 0x20) {
       wch = 0x20;
     }
     if (wch == 0x20 && wPrev == 0x20) {
       continue;
     }
     wPrev = wch;
     psz[iTrimLeft++] = wch;
   }
   wsText.ReleaseBuffer(iLen);
   wsText = wsText.Left(iTrimLeft);
 }
 void CXFA_TextLayout::EndBreak(uint32_t dwStatus,
                                FX_FLOAT& fLinePos,
-                               FX_BOOL bSavePieces) {
+                               bool bSavePieces) {
   dwStatus = m_pBreak->EndBreak(dwStatus);
   if (dwStatus > FX_RTFBREAK_PieceBreak) {
-    AppendTextLine(dwStatus, fLinePos, bSavePieces, TRUE);
+    AppendTextLine(dwStatus, fLinePos, bSavePieces, true);
   }
 }
 void CXFA_TextLayout::DoTabstops(IFDE_CSSComputedStyle* pStyle,
                                  CXFA_PieceLine* pPieceLine) {
   if (!m_pTabstopContext || m_pTabstopContext->m_iTabCount == 0) {
     return;
   }
   if (!pStyle || !pPieceLine) {
     return;
   }
   int32_t iPieces = pPieceLine->m_textPieces.GetSize();
   if (iPieces == 0) {
     return;
   }
   XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPieces - 1);
   int32_t& iTabstopsIndex = m_pTabstopContext->m_iTabIndex;
   int32_t iCount = m_textParser.CountTabs(pStyle);
   if (iTabstopsIndex > m_pTabstopContext->m_iTabCount - 1) {
     return;
   }
   if (iCount > 0) {
     iTabstopsIndex++;
-    m_pTabstopContext->m_bTabstops = TRUE;
+    m_pTabstopContext->m_bTabstops = true;
     FX_FLOAT fRight = 0;
     if (iPieces > 1) {
       XFA_TextPiece* p = pPieceLine->m_textPieces.GetAt(iPieces - 2);
       fRight = p->rtPiece.right();
     }
     m_pTabstopContext->m_fTabWidth =
         pPiece->rtPiece.width + pPiece->rtPiece.left - fRight;
   } else if (iTabstopsIndex > -1) {
     FX_FLOAT fLeft = 0;
     if (m_pTabstopContext->m_bTabstops) {
       XFA_TABSTOPS* pTabstops =
           m_pTabstopContext->m_tabstops.GetDataPtr(iTabstopsIndex);
       uint32_t dwAlign = pTabstops->dwAlign;
       if (dwAlign == FX_HashCode_GetW(L"center", false)) {
         fLeft = pPiece->rtPiece.width / 2.0f;
       } else if (dwAlign == FX_HashCode_GetW(L"right", false) ||
                  dwAlign == FX_HashCode_GetW(L"before", false)) {
         fLeft = pPiece->rtPiece.width;
       } else if (dwAlign == FX_HashCode_GetW(L"decimal", false)) {
         int32_t iChars = pPiece->iChars;
         for (int32_t i = 0; i < iChars; i++) {
           if (pPiece->pszText[i] == L'.') {
             break;
           }
           fLeft += pPiece->pWidths[i] / 20000.0f;
         }
       }
       m_pTabstopContext->m_fLeft =
           std::min(fLeft, m_pTabstopContext->m_fTabWidth);
-      m_pTabstopContext->m_bTabstops = FALSE;
+      m_pTabstopContext->m_bTabstops = false;
       m_pTabstopContext->m_fTabWidth = 0;
     }
     pPiece->rtPiece.left -= m_pTabstopContext->m_fLeft;
   }
 }
 void CXFA_TextLayout::AppendTextLine(uint32_t dwStatus,
                                      FX_FLOAT& fLinePos,
-                                     FX_BOOL bSavePieces,
-                                     FX_BOOL bEndBreak) {
+                                     bool bSavePieces,
+                                     bool bEndBreak) {
   int32_t iPieces = m_pBreak->CountBreakPieces();
   if (iPieces < 1) {
     return;
   }
   IFDE_CSSComputedStyle* pStyle = nullptr;
   if (bSavePieces) {
     CXFA_PieceLine* pPieceLine =
         FXTARGET_NewWith(m_pAllocator.get()) CXFA_PieceLine;
     m_pieceLines.Add(pPieceLine);
     if (m_pTabstopContext) {
@@ skipping 145 matching lines @@
   pPieceLine->m_charCounts.Add(iCount);
 }
 
 void CXFA_TextLayout::RenderPath(CFDE_RenderDevice* pDevice,
                                  CFDE_Pen* pPen,
                                  CXFA_PieceLine* pPieceLine,
                                  int32_t iPiece,
                                  FXTEXT_CHARPOS* pCharPos,
                                  const CFX_Matrix& tmDoc2Device) {
   XFA_TextPiece* pPiece = pPieceLine->m_textPieces.GetAt(iPiece);
-  FX_BOOL bNoUnderline = pPiece->iUnderline < 1 || pPiece->iUnderline > 2;
-  FX_BOOL bNoLineThrough = pPiece->iLineThrough < 1 || pPiece->iLineThrough > 2;
+  bool bNoUnderline = pPiece->iUnderline < 1 || pPiece->iUnderline > 2;
+  bool bNoLineThrough = pPiece->iLineThrough < 1 || pPiece->iLineThrough > 2;
   if (bNoUnderline && bNoLineThrough) {
     return;
   }
   pPen->SetColor(pPiece->dwColor);
   std::unique_ptr<CFDE_Path> pPath(new CFDE_Path);
   int32_t iChars = GetDisplayPos(pPiece, pCharPos);
   if (iChars > 0) {
     CFX_PointF pt1, pt2;
     FX_FLOAT fEndY = pCharPos[0].m_OriginY + 1.05f;
     if (pPiece->iPeriod == XFA_ATTRIBUTEENUM_Word) {
@@ skipping 83 matching lines @@
       pt1.y = pt2.y = fEndY;
       pPath->AddLine(pt1, pt2);
       fEndY += 2.0f;
     }
   }
   pDevice->DrawPath(pPen, 1, pPath.get(), &tmDoc2Device);
 }
 
 int32_t CXFA_TextLayout::GetDisplayPos(const XFA_TextPiece* pPiece,
                                        FXTEXT_CHARPOS* pCharPos,
-                                       FX_BOOL bCharCode) {
+                                       bool bCharCode) {
   if (!pPiece) {
     return 0;
   }
   FX_RTFTEXTOBJ tr;
   if (!ToRun(pPiece, tr)) {
     return 0;
   }
   return m_pBreak->GetDisplayPos(&tr, pCharPos, bCharCode);
 }
-FX_BOOL CXFA_TextLayout::ToRun(const XFA_TextPiece* pPiece, FX_RTFTEXTOBJ& tr) {
+bool CXFA_TextLayout::ToRun(const XFA_TextPiece* pPiece, FX_RTFTEXTOBJ& tr) {
   int32_t iLength = pPiece->iChars;
   if (iLength < 1) {
-    return FALSE;
+    return false;
   }
   tr.pStr = pPiece->pszText;
   tr.pFont = pPiece->pFont;
   tr.pRect = &pPiece->rtPiece;
   tr.pWidths = pPiece->pWidths;
   tr.iLength = iLength;
   tr.fFontSize = pPiece->fFontSize;
   tr.iBidiLevel = pPiece->iBidiLevel;
   tr.iCharRotation = 0;
   tr.wLineBreakChar = L'\n';
   tr.iVerticalScale = pPiece->iVerScale;
   tr.dwLayoutStyles = FX_RTFLAYOUTSTYLE_ExpandTab;
   tr.iHorizontalScale = pPiece->iHorScale;
-  return TRUE;
+  return true;
 }
 
 CXFA_LinkUserData::CXFA_LinkUserData(IFX_MemoryAllocator* pAllocator,
                                      FX_WCHAR* pszText)
     : m_pAllocator(pAllocator), m_dwRefCount(1), m_wsURLContent(pszText) {}
 
 CXFA_LinkUserData::~CXFA_LinkUserData() {}
 
 uint32_t CXFA_LinkUserData::Retain() {
   return ++m_dwRefCount;
@@ skipping 51 matching lines @@
   return dwRefCount;
 }
 
 CXFA_PieceLine::CXFA_PieceLine() {}
 
 CXFA_PieceLine::~CXFA_PieceLine() {}
 
 CXFA_TextTabstopsContext::CXFA_TextTabstopsContext()
     : m_iTabCount(0),
       m_iTabIndex(-1),
-      m_bTabstops(FALSE),
+      m_bTabstops(false),
       m_fTabWidth(0),
       m_fLeft(0) {}
 
 CXFA_TextTabstopsContext::~CXFA_TextTabstopsContext() {}
 
 void CXFA_TextTabstopsContext::Append(uint32_t dwAlign, FX_FLOAT fTabstops) {
   int32_t i = 0;
   for (i = 0; i < m_iTabCount; i++) {
     XFA_TABSTOPS* pTabstop = m_tabstops.GetDataPtr(i);
     if (fTabstops < pTabstop->fTabstops) {
       break;
     }
   }
   m_tabstops.InsertSpaceAt(i, 1);
   XFA_TABSTOPS tabstop;
   tabstop.dwAlign = dwAlign;
   tabstop.fTabstops = fTabstops;
   m_tabstops.SetAt(i, tabstop);
   m_iTabCount++;
 }
 
 void CXFA_TextTabstopsContext::RemoveAll() {
   m_tabstops.RemoveAll();
   m_iTabCount = 0;
 }
 
 void CXFA_TextTabstopsContext::Reset() {
   m_iTabIndex = -1;
-  m_bTabstops = FALSE;
+  m_bTabstops = false;
   m_fTabWidth = 0;
   m_fLeft = 0;
 }