Remove FX_BOOL from xfa.

xfa/fgas/layout/fgas_rtfbreak.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/fgas/layout/fgas_rtfbreak.h"
 
 #include <algorithm>
 
@@ skipping 10 matching lines @@
       m_dwLayoutStyles(0),
       m_bPagination(false),
       m_bVertical(false),
       m_bSingleLine(false),
       m_bCharCode(false),
       m_pFont(nullptr),
       m_iFontHeight(240),
       m_iFontSize(240),
       m_iTabWidth(720000),
       m_PositionedTabs(),
-      m_bOrphanLine(FALSE),
+      m_bOrphanLine(false),
       m_wDefChar(0xFEFF),
       m_iDefChar(0),
       m_wLineBreakChar(L'\n'),
       m_iHorizontalScale(100),
       m_iVerticalScale(100),
       m_iLineRotation(0),
       m_iCharRotation(0),
       m_iRotation(0),
       m_iCharSpace(0),
-      m_bWordSpace(FALSE),
+      m_bWordSpace(false),
       m_iWordSpace(0),
-      m_bRTL(FALSE),
+      m_bRTL(false),
       m_iAlignment(FX_RTFLINEALIGNMENT_Left),
       m_pUserData(nullptr),
       m_eCharType(FX_CHARTYPE_Unknown),
       m_dwIdentity(0),
       m_RTFLine1(),
       m_RTFLine2(),
       m_pCurLine(nullptr),
       m_iReady(0),
       m_iTolerance(0) {
   m_pCurLine = &m_RTFLine1;
@@ skipping 44 matching lines @@
   }
   if (m_pFont == pFont) {
     return;
   }
   SetBreakStatus();
   m_pFont = pFont;
   m_iDefChar = 0;
   if (m_pFont) {
     m_iFontHeight = m_iFontSize;
     if (m_wDefChar != 0xFEFF) {
-      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
+      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetFontSize(FX_FLOAT fFontSize) {
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   if (m_iFontSize == iFontSize) {
     return;
   }
   SetBreakStatus();
   m_iFontSize = iFontSize;
   m_iDefChar = 0;
   if (m_pFont) {
     m_iFontHeight = m_iFontSize;
     if (m_wDefChar != 0xFEFF) {
-      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
+      m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetTabWidth(FX_FLOAT fTabWidth) {
   m_iTabWidth = FXSYS_round(fTabWidth * 20000.0f);
 }
 void CFX_RTFBreak::AddPositionedTab(FX_FLOAT fTabPos) {
   int32_t iLineEnd = m_iBoundaryEnd;
   int32_t iTabPos = FXSYS_round(fTabPos * 20000.0f) + m_iBoundaryStart;
   if (iTabPos > iLineEnd) {
     iTabPos = iLineEnd;
   }
   if (m_PositionedTabs.Find(iTabPos, 0) > -1) {
     return;
   }
   int32_t iCount = m_PositionedTabs.GetSize();
   int32_t iFind = 0;
   for (; iFind < iCount; iFind++) {
     if (m_PositionedTabs[iFind] > iTabPos) {
       break;
     }
   }
   m_PositionedTabs.InsertAt(iFind, iTabPos);
   if (m_dwPolicies & FX_RTFBREAKPOLICY_OrphanPositionedTab) {
     m_bOrphanLine = GetLastPositionedTab() >= iLineEnd;
   } else {
-    m_bOrphanLine = FALSE;
+    m_bOrphanLine = false;
   }
 }
 void CFX_RTFBreak::SetPositionedTabs(const CFX_FloatArray& tabs) {
   m_PositionedTabs.RemoveAll();
   int32_t iCount = tabs.GetSize();
   m_PositionedTabs.SetSize(iCount);
   int32_t iLineEnd = m_iBoundaryEnd;
   int32_t iTabPos;
   for (int32_t i = 0; i < iCount; i++) {
     iTabPos = FXSYS_round(tabs[i] * 20000.0f) + m_iBoundaryStart;
     if (iTabPos > iLineEnd) {
       iTabPos = iLineEnd;
     }
     m_PositionedTabs[i] = iTabPos;
   }
   if (m_dwPolicies & FX_RTFBREAKPOLICY_OrphanPositionedTab) {
     m_bOrphanLine = GetLastPositionedTab() >= iLineEnd;
   } else {
-    m_bOrphanLine = FALSE;
+    m_bOrphanLine = false;
   }
 }
 void CFX_RTFBreak::ClearPositionedTabs() {
   m_PositionedTabs.RemoveAll();
-  m_bOrphanLine = FALSE;
+  m_bOrphanLine = false;
 }
 void CFX_RTFBreak::SetDefaultChar(FX_WCHAR wch) {
   m_wDefChar = wch;
   m_iDefChar = 0;
   if (m_wDefChar != 0xFEFF && m_pFont) {
-    m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, FALSE);
+    m_pFont->GetCharWidth(m_wDefChar, m_iDefChar, false);
     if (m_iDefChar < 0) {
       m_iDefChar = 0;
     } else {
       m_iDefChar *= m_iFontSize;
     }
   }
 }
 void CFX_RTFBreak::SetLineBreakChar(FX_WCHAR wch) {
   if (wch != L'\r' && wch != L'\n') {
     return;
@@ skipping 33 matching lines @@
     return;
   }
   SetBreakStatus();
   m_iCharRotation = iCharRotation;
   m_iRotation = m_iLineRotation + m_iCharRotation;
   m_iRotation %= 4;
 }
 void CFX_RTFBreak::SetCharSpace(FX_FLOAT fCharSpace) {
   m_iCharSpace = FXSYS_round(fCharSpace * 20000.0f);
 }
-void CFX_RTFBreak::SetWordSpace(FX_BOOL bDefault, FX_FLOAT fWordSpace) {
+void CFX_RTFBreak::SetWordSpace(bool bDefault, FX_FLOAT fWordSpace) {
   m_bWordSpace = !bDefault;
   m_iWordSpace = FXSYS_round(fWordSpace * 20000.0f);
 }
-void CFX_RTFBreak::SetReadingOrder(FX_BOOL bRTL) {
+void CFX_RTFBreak::SetReadingOrder(bool bRTL) {
   m_bRTL = bRTL;
 }
 void CFX_RTFBreak::SetAlignment(int32_t iAlignment) {
   ASSERT(iAlignment >= FX_RTFLINEALIGNMENT_Left &&
          iAlignment <= FX_RTFLINEALIGNMENT_Distributed);
   m_iAlignment = iAlignment;
 }
 void CFX_RTFBreak::SetUserData(IFX_Retainable* pUserData) {
   if (m_pUserData == pUserData) {
     return;
@@ skipping 34 matching lines @@
     pTC = tca.GetDataPtr(iStart--);
     if (pTC->m_iCharWidth >= 0 ||
         pTC->GetCharType() != FX_CHARTYPE_Combination) {
       if (--index < 0) {
         return pTC;
       }
     }
   }
   return nullptr;
 }
-CFX_RTFLine* CFX_RTFBreak::GetRTFLine(FX_BOOL bReady) const {
+CFX_RTFLine* CFX_RTFBreak::GetRTFLine(bool bReady) const {
   if (bReady) {
     if (m_iReady == 1) {
       return (CFX_RTFLine*)&m_RTFLine1;
     } else if (m_iReady == 2) {
       return (CFX_RTFLine*)&m_RTFLine2;
     } else {
       return nullptr;
     }
   }
   ASSERT(m_pCurLine);
   return m_pCurLine;
 }
-CFX_RTFPieceArray* CFX_RTFBreak::GetRTFPieces(FX_BOOL bReady) const {
+CFX_RTFPieceArray* CFX_RTFBreak::GetRTFPieces(bool bReady) const {
   CFX_RTFLine* pRTFLine = GetRTFLine(bReady);
   return pRTFLine ? &pRTFLine->m_LinePieces : nullptr;
 }
 inline FX_CHARTYPE CFX_RTFBreak::GetUnifiedCharType(
     FX_CHARTYPE chartype) const {
   return chartype >= FX_CHARTYPE_ArabicAlef ? FX_CHARTYPE_Arabic : chartype;
 }
 int32_t CFX_RTFBreak::GetLastPositionedTab() const {
   int32_t iCount = m_PositionedTabs.GetSize();
   if (iCount < 1) {
     return m_iBoundaryStart;
   }
   return m_PositionedTabs[iCount - 1];
 }
-FX_BOOL CFX_RTFBreak::GetPositionedTab(int32_t& iTabPos) const {
+bool CFX_RTFBreak::GetPositionedTab(int32_t& iTabPos) const {
   int32_t iCount = m_PositionedTabs.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     if (m_PositionedTabs[i] > iTabPos) {
       iTabPos = m_PositionedTabs[i];
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 typedef uint32_t (CFX_RTFBreak::*FX_RTFBreak_LPFAppendChar)(
     CFX_RTFChar* pCurChar,
     int32_t iRotation);
 static const FX_RTFBreak_LPFAppendChar g_FX_RTFBreak_lpfAppendChar[16] = {
     &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Tab,
     &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Control,
     &CFX_RTFBreak::AppendChar_Combination, &CFX_RTFBreak::AppendChar_Others,
     &CFX_RTFBreak::AppendChar_Others,      &CFX_RTFBreak::AppendChar_Arabic,
     &CFX_RTFBreak::AppendChar_Arabic,      &CFX_RTFBreak::AppendChar_Arabic,
@@ skipping 71 matching lines @@
   pCurChar->m_iCharWidth = 0;
   pCurChar->m_dwIdentity = m_dwIdentity;
   if (m_pUserData)
     m_pUserData->Retain();
 
   pCurChar->m_pUserData = m_pUserData;
   int32_t iCharWidth = 0;
   if (m_bVertical != FX_IsOdd(m_iRotation)) {
     iCharWidth = 1000;
   } else {
-    if (!m_pFont->GetCharWidth(wch, iCharWidth, TRUE)) {
+    if (!m_pFont->GetCharWidth(wch, iCharWidth, true)) {
       iCharWidth = m_iDefChar;
     }
   }
   iCharWidth *= m_iFontSize;
   iCharWidth = iCharWidth * m_iHorizontalScale / 100;
   iCharWidth += m_iCharSpace;
   pCurChar->m_iCharWidth = iCharWidth;
   m_pCurLine->m_iWidth += iCharWidth;
   m_eCharType = FX_CHARTYPE_Unknown;
   if (!m_bSingleLine &&
@@ skipping 24 matching lines @@
   }
   pCurChar->m_iCharWidth = iCharWidth;
   if (iCharWidth > 0) {
     m_pCurLine->m_iWidth += iCharWidth;
   }
   return FX_RTFBREAK_None;
 }
 uint32_t CFX_RTFBreak::AppendChar_Tab(CFX_RTFChar* pCurChar,
                                       int32_t iRotation) {
   if (m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_ExpandTab) {
-    FX_BOOL bBreak = FALSE;
+    bool bBreak = false;
     if ((m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0) {
       bBreak = (m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance);
     }
     int32_t& iLineWidth = m_pCurLine->m_iWidth;
     int32_t iCharWidth = iLineWidth;
     if (GetPositionedTab(iCharWidth)) {
       iCharWidth -= iLineWidth;
     } else {
       iCharWidth = m_iTabWidth * (iLineWidth / m_iTabWidth + 1) - iLineWidth;
     }
@@ skipping 32 matching lines @@
   }
   return dwRet2;
 }
 
 uint32_t CFX_RTFBreak::AppendChar_Arabic(CFX_RTFChar* pCurChar,
                                          int32_t iRotation) {
   CFX_RTFChar* pLastChar = nullptr;
   int32_t& iLineWidth = m_pCurLine->m_iWidth;
   int32_t iCharWidth = 0;
   FX_WCHAR wForm;
-  FX_BOOL bAlef = FALSE;
+  bool bAlef = false;
   if (m_eCharType >= FX_CHARTYPE_ArabicAlef &&
       m_eCharType <= FX_CHARTYPE_ArabicDistortion) {
     pLastChar = GetLastChar(1);
     if (pLastChar) {
       iLineWidth -= pLastChar->m_iCharWidth;
       CFX_RTFChar* pPrevChar = GetLastChar(2);
       wForm = pdfium::arabic::GetFormChar(pLastChar, pPrevChar, pCurChar);
       bAlef = (wForm == 0xFEFF &&
                pLastChar->GetCharType() == FX_CHARTYPE_ArabicAlef);
       int32_t iLastRotation = pLastChar->m_nRotation + m_iLineRotation;
@@ skipping 86 matching lines @@
   int32_t iCount = pCurPieces->GetSize();
   if (iCount > 0) {
     CFX_RTFPiece* pLastPiece = pCurPieces->GetPtrAt(--iCount);
     if (dwStatus > FX_RTFBREAK_PieceBreak)
       pLastPiece->m_dwStatus = dwStatus;
     else
       dwStatus = pLastPiece->m_dwStatus;
     return dwStatus;
   }
 
-  CFX_RTFLine* pLastLine = GetRTFLine(TRUE);
+  CFX_RTFLine* pLastLine = GetRTFLine(true);
   if (pLastLine) {
     pCurPieces = &pLastLine->m_LinePieces;
     iCount = pCurPieces->GetSize();
     if (iCount-- > 0) {
       CFX_RTFPiece* pLastPiece = pCurPieces->GetPtrAt(iCount);
       if (dwStatus > FX_RTFBREAK_PieceBreak)
         pLastPiece->m_dwStatus = dwStatus;
       else
         dwStatus = pLastPiece->m_dwStatus;
       return dwStatus;
     }
     return FX_RTFBREAK_None;
   }
   iCount = m_pCurLine->CountChars();
   if (iCount < 1)
     return FX_RTFBREAK_None;
 
   CFX_RTFChar& tc = m_pCurLine->GetChar(iCount - 1);
   tc.m_dwStatus = dwStatus;
   if (dwStatus <= FX_RTFBREAK_PieceBreak)
     return dwStatus;
 
   m_iReady = (m_pCurLine == &m_RTFLine1) ? 1 : 2;
   CFX_RTFLine* pNextLine =
       (m_pCurLine == &m_RTFLine1) ? &m_RTFLine2 : &m_RTFLine1;
-  FX_BOOL bAllChars = (m_iAlignment > FX_RTFLINEALIGNMENT_Right);
+  bool bAllChars = (m_iAlignment > FX_RTFLINEALIGNMENT_Right);
   CFX_TPOArray tpos(100);
   if (!EndBreak_SplitLine(pNextLine, bAllChars, dwStatus)) {
     if (!m_bCharCode)
       EndBreak_BidiLine(tpos, dwStatus);
 
     if (!m_bPagination && m_iAlignment > FX_RTFLINEALIGNMENT_Left)
       EndBreak_Alignment(tpos, bAllChars, dwStatus);
   }
 
   m_pCurLine = pNextLine;
   m_pCurLine->m_iStart = m_iBoundaryStart;
   CFX_RTFChar* pTC = GetLastChar(0);
   m_eCharType = pTC ? pTC->GetCharType() : FX_CHARTYPE_Unknown;
   return dwStatus;
 }
 
-FX_BOOL CFX_RTFBreak::EndBreak_SplitLine(CFX_RTFLine* pNextLine,
-                                         FX_BOOL bAllChars,
-                                         uint32_t dwStatus) {
-  FX_BOOL bDone = FALSE;
+bool CFX_RTFBreak::EndBreak_SplitLine(CFX_RTFLine* pNextLine,
+                                      bool bAllChars,
+                                      uint32_t dwStatus) {
+  bool bDone = false;
   if (!m_bSingleLine && !m_bOrphanLine &&
       m_pCurLine->GetLineEnd() > m_iBoundaryEnd + m_iTolerance) {
     CFX_RTFChar& tc = m_pCurLine->GetChar(m_pCurLine->CountChars() - 1);
     switch (tc.GetCharType()) {
       case FX_CHARTYPE_Tab:
         if ((m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0) {
           SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
-          bDone = TRUE;
+          bDone = true;
         }
         break;
       case FX_CHARTYPE_Control:
         break;
       case FX_CHARTYPE_Space:
         if ((m_dwPolicies & FX_RTFBREAKPOLICY_SpaceBreak) != 0) {
           SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
-          bDone = TRUE;
+          bDone = true;
         }
         break;
       default:
         SplitTextLine(m_pCurLine, pNextLine, !m_bPagination && bAllChars);
-        bDone = TRUE;
+        bDone = true;
         break;
     }
   }
   if (m_bPagination || m_pCurLine->m_iMBCSChars > 0) {
     const CFX_RTFChar* pCurChars = m_pCurLine->m_LineChars.GetData();
     const CFX_RTFChar* pTC;
     CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
     CFX_RTFPiece tp;
     tp.m_pChars = &m_pCurLine->m_LineChars;
-    FX_BOOL bNew = TRUE;
+    bool bNew = true;
     uint32_t dwIdentity = (uint32_t)-1;
     int32_t iLast = m_pCurLine->CountChars() - 1, j = 0;
     for (int32_t i = 0; i <= iLast;) {
       pTC = pCurChars + i;
       if (bNew) {
         tp.m_iStartChar = i;
         tp.m_iStartPos += tp.m_iWidth;
         tp.m_iWidth = 0;
         tp.m_dwStatus = pTC->m_dwStatus;
         tp.m_iFontSize = pTC->m_iFontSize;
         tp.m_iFontHeight = pTC->m_iFontHeight;
         tp.m_iHorizontalScale = pTC->m_iHorizontalScale;
         tp.m_iVerticalScale = pTC->m_iVertialScale;
         tp.m_dwLayoutStyles = pTC->m_dwLayoutStyles;
         dwIdentity = pTC->m_dwIdentity;
         tp.m_dwIdentity = dwIdentity;
         tp.m_pUserData = pTC->m_pUserData;
         j = i;
-        bNew = FALSE;
+        bNew = false;
       }
       if (i == iLast || pTC->m_dwStatus != FX_RTFBREAK_None ||
           pTC->m_dwIdentity != dwIdentity) {
         tp.m_iChars = i - j;
         if (pTC->m_dwIdentity == dwIdentity) {
           tp.m_dwStatus = pTC->m_dwStatus;
           tp.m_iWidth += pTC->m_iCharWidth;
           tp.m_iChars += 1;
           i++;
         }
         pCurPieces->Add(tp);
-        bNew = TRUE;
+        bNew = true;
       } else {
         tp.m_iWidth += pTC->m_iCharWidth;
         i++;
       }
     }
-    return TRUE;
+    return true;
   }
   if (bAllChars && !bDone) {
     int32_t iEndPos = m_pCurLine->GetLineEnd();
-    GetBreakPos(m_pCurLine->m_LineChars, iEndPos, bAllChars, TRUE);
+    GetBreakPos(m_pCurLine->m_LineChars, iEndPos, bAllChars, true);
   }
-  return FALSE;
+  return false;
 }
 void CFX_RTFBreak::EndBreak_BidiLine(CFX_TPOArray& tpos, uint32_t dwStatus) {
   FX_TPO tpo;
   CFX_RTFPiece tp;
   CFX_RTFChar* pTC;
   int32_t i, j;
   CFX_RTFCharArray& chars = m_pCurLine->m_LineChars;
   int32_t iCount = m_pCurLine->CountChars();
-  FX_BOOL bDone = (!m_bPagination && !m_bCharCode &&
-                   (m_pCurLine->m_iArabicChars > 0 || m_bRTL));
+  bool bDone = (!m_bPagination && !m_bCharCode &&
+                (m_pCurLine->m_iArabicChars > 0 || m_bRTL));
   if (bDone) {
     int32_t iBidiNum = 0;
     for (i = 0; i < iCount; i++) {
       pTC = chars.GetDataPtr(i);
       pTC->m_iBidiPos = i;
       if (pTC->GetCharType() != FX_CHARTYPE_Control) {
         iBidiNum = i;
       }
       if (i == 0) {
         pTC->m_iBidiLevel = 1;
@@ skipping 68 matching lines @@
     int32_t iStartPos = m_pCurLine->m_iStart;
     for (i = 0; i <= j; i++) {
       tpo = tpos.GetAt(i);
       CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
       ttp.m_iStartPos = iStartPos;
       iStartPos += ttp.m_iWidth;
     }
   }
 }
 void CFX_RTFBreak::EndBreak_Alignment(CFX_TPOArray& tpos,
-                                      FX_BOOL bAllChars,
+                                      bool bAllChars,
                                       uint32_t dwStatus) {
   CFX_RTFPieceArray* pCurPieces = &m_pCurLine->m_LinePieces;
   int32_t iNetWidth = m_pCurLine->m_iWidth, iGapChars = 0, iCharWidth;
   int32_t iCount = pCurPieces->GetSize();
-  FX_BOOL bFind = FALSE;
+  bool bFind = false;
   uint32_t dwCharType;
   int32_t i, j;
   FX_TPO tpo;
   for (i = iCount - 1; i > -1; i--) {
     tpo = tpos.GetAt(i);
     CFX_RTFPiece& ttp = pCurPieces->GetAt(tpo.index);
     if (!bFind) {
       iNetWidth = ttp.GetEndPos();
     }
-    FX_BOOL bArabic = FX_IsOdd(ttp.m_iBidiLevel);
+    bool bArabic = FX_IsOdd(ttp.m_iBidiLevel);
     j = bArabic ? 0 : ttp.m_iChars - 1;
     while (j > -1 && j < ttp.m_iChars) {
       const CFX_RTFChar& tc = ttp.GetChar(j);
       if (tc.m_nBreakType == FX_LBT_DIRECT_BRK) {
         iGapChars++;
       }
       if (!bFind || !bAllChars) {
         dwCharType = tc.GetCharType();
         if (dwCharType == FX_CHARTYPE_Space ||
             dwCharType == FX_CHARTYPE_Control) {
           if (!bFind) {
             iCharWidth = tc.m_iCharWidth;
             if (bAllChars && iCharWidth > 0) {
               iNetWidth -= iCharWidth;
             }
           }
         } else {
-          bFind = TRUE;
+          bFind = true;
           if (!bAllChars) {
             break;
           }
         }
       }
       j += bArabic ? 1 : -1;
     }
     if (!bAllChars && bFind) {
       break;
     }
@@ skipping 38 matching lines @@
       for (i = 0; i < iCount; i++) {
         CFX_RTFPiece& ttp = pCurPieces->GetAt(i);
         ttp.m_iStartPos += iOffset;
       }
     }
   }
 }
 
 int32_t CFX_RTFBreak::GetBreakPos(CFX_RTFCharArray& tca,
                                   int32_t& iEndPos,
-                                  FX_BOOL bAllChars,
-                                  FX_BOOL bOnlyBrk) {
+                                  bool bAllChars,
+                                  bool bOnlyBrk) {
   int32_t iLength = tca.GetSize() - 1;
   if (iLength < 1)
     return iLength;
 
   int32_t iBreak = -1, iBreakPos = -1, iIndirect = -1, iIndirectPos = -1,
           iLast = -1, iLastPos = -1;
   if (m_bSingleLine || m_bOrphanLine || iEndPos <= m_iBoundaryEnd) {
     if (!bAllChars || m_bCharCode)
       return iLength;
 
     iBreak = iLength;
     iBreakPos = iEndPos;
   }
   CFX_RTFChar* pCharArray = tca.GetData();
   if (m_bCharCode) {
     const CFX_RTFChar* pChar;
     int32_t iCharWidth;
     while (iLength > 0) {
       if (iEndPos <= m_iBoundaryEnd)
         break;
 
       pChar = pCharArray + iLength--;
       iCharWidth = pChar->m_iCharWidth;
       if (iCharWidth > 0)
         iEndPos -= iCharWidth;
     }
     return iLength;
   }
-  FX_BOOL bSpaceBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_SpaceBreak) != 0;
-  FX_BOOL bTabBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0;
-  FX_BOOL bNumberBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_NumberBreak) != 0;
-  FX_BOOL bInfixBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_InfixBreak) != 0;
+  bool bSpaceBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_SpaceBreak) != 0;
+  bool bTabBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_TabBreak) != 0;
+  bool bNumberBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_NumberBreak) != 0;
+  bool bInfixBreak = (m_dwPolicies & FX_RTFBREAKPOLICY_InfixBreak) != 0;
   FX_LINEBREAKTYPE eType;
   uint32_t nCodeProp, nCur, nNext;
   CFX_RTFChar* pCur = pCharArray + iLength--;
   if (bAllChars) {
     pCur->m_nBreakType = FX_LBT_UNKNOWN;
   }
   nCodeProp = pCur->m_dwCharProps;
   nNext = nCodeProp & 0x003F;
   int32_t iCharWidth = pCur->m_iCharWidth;
   if (iCharWidth > 0) {
     iEndPos -= iCharWidth;
   }
   while (iLength >= 0) {
     pCur = pCharArray + iLength;
     nCodeProp = pCur->m_dwCharProps;
     nCur = nCodeProp & 0x003F;
-    FX_BOOL bNeedBreak = FALSE;
+    bool bNeedBreak = false;
     if (nCur == FX_CBP_SP) {
       bNeedBreak = !bSpaceBreak;
       if (nNext == FX_CBP_SP) {
         eType = bSpaceBreak ? FX_LBT_DIRECT_BRK : FX_LBT_PROHIBITED_BRK;
       } else {
         eType = gs_FX_LineBreak_PairTable[nCur][nNext];
       }
     } else if (nCur == FX_CBP_TB) {
       bNeedBreak = !bTabBreak;
       if (nNext == FX_CBP_TB) {
         eType = bTabBreak ? FX_LBT_DIRECT_BRK : FX_LBT_PROHIBITED_BRK;
       } else {
         eType = gs_FX_LineBreak_PairTable[nCur][nNext];
       }
     } else if ((bNumberBreak && nCur == FX_CBP_NU && nNext == FX_CBP_NU) ||
                (bInfixBreak && nCur == FX_CBP_IS && nNext == FX_CBP_IS)) {
       eType = FX_LBT_DIRECT_BRK;
     } else {
       if (nNext == FX_CBP_SP) {
         eType = FX_LBT_PROHIBITED_BRK;
       } else {
         eType = gs_FX_LineBreak_PairTable[nCur][nNext];
       }
     }
     if (bAllChars) {
       pCur->m_nBreakType = eType;
     }
     if (!bOnlyBrk) {
       iCharWidth = pCur->m_iCharWidth;
-      FX_BOOL bBreak = FALSE;
+      bool bBreak = false;
       if (nCur == FX_CBP_TB && bTabBreak) {
         bBreak = iCharWidth > 0 && iEndPos - iCharWidth <= m_iBoundaryEnd;
       } else {
         bBreak = iEndPos <= m_iBoundaryEnd;
       }
       if (m_bSingleLine || m_bOrphanLine || bBreak || bNeedBreak) {
         if (eType == FX_LBT_DIRECT_BRK && iBreak < 0) {
           iBreak = iLength;
           iBreakPos = iEndPos;
           if (!bAllChars) {
@@ skipping 28 matching lines @@
   }
   if (iLast > -1) {
     iEndPos = iLastPos;
     return iLast;
   }
   return 0;
 }
 
 void CFX_RTFBreak::SplitTextLine(CFX_RTFLine* pCurLine,
                                  CFX_RTFLine* pNextLine,
-                                 FX_BOOL bAllChars) {
+                                 bool bAllChars) {
   ASSERT(pCurLine && pNextLine);
   int32_t iCount = pCurLine->CountChars();
   if (iCount < 2) {
     return;
   }
   int32_t iEndPos = pCurLine->GetLineEnd();
   CFX_RTFCharArray& curChars = pCurLine->m_LineChars;
-  int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, FALSE);
+  int32_t iCharPos = GetBreakPos(curChars, iEndPos, bAllChars, false);
   if (iCharPos < 0) {
     iCharPos = 0;
   }
   iCharPos++;
   if (iCharPos >= iCount) {
-    pNextLine->RemoveAll(TRUE);
+    pNextLine->RemoveAll(true);
     CFX_Char* pTC = curChars.GetDataPtr(iCharPos - 1);
     pTC->m_nBreakType = FX_LBT_UNKNOWN;
     return;
   }
   CFX_RTFCharArray& nextChars = pNextLine->m_LineChars;
   int cur_size = curChars.GetSize();
   nextChars.SetSize(cur_size - iCharPos);
   FXSYS_memcpy(nextChars.GetData(), curChars.GetDataPtr(iCharPos),
                (cur_size - iCharPos) * sizeof(CFX_RTFChar));
   iCount -= iCharPos;
@@ skipping 13 matching lines @@
     }
     if (tc->m_dwLayoutStyles & FX_RTFLAYOUTSTYLE_MBCSCode) {
       pCurLine->m_iMBCSChars--;
       pNextLine->m_iMBCSChars++;
     }
     tc->m_dwStatus = 0;
   }
 }
 
 int32_t CFX_RTFBreak::CountBreakPieces() const {
-  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(TRUE);
+  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(true);
   return pRTFPieces ? pRTFPieces->GetSize() : 0;
 }
 
 const CFX_RTFPiece* CFX_RTFBreak::GetBreakPiece(int32_t index) const {
-  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(TRUE);
+  CFX_RTFPieceArray* pRTFPieces = GetRTFPieces(true);
   if (!pRTFPieces)
     return nullptr;
 
   if (index < 0 || index >= pRTFPieces->GetSize())
     return nullptr;
 
   return pRTFPieces->GetPtrAt(index);
 }
 
 void CFX_RTFBreak::GetLineRect(CFX_RectF& rect) const {
   rect.top = 0;
-  CFX_RTFLine* pRTFLine = GetRTFLine(TRUE);
+  CFX_RTFLine* pRTFLine = GetRTFLine(true);
   if (!pRTFLine) {
     rect.left = ((FX_FLOAT)m_iBoundaryStart) / 20000.0f;
     rect.width = rect.height = 0;
     return;
   }
   rect.left = ((FX_FLOAT)pRTFLine->m_iStart) / 20000.0f;
   rect.width = ((FX_FLOAT)pRTFLine->m_iWidth) / 20000.0f;
   CFX_RTFPieceArray& rtfPieces = pRTFLine->m_LinePieces;
   int32_t iCount = rtfPieces.GetSize();
   if (iCount < 1) {
     rect.width = 0;
     return;
   }
   CFX_RTFPiece* pBreakPiece;
   int32_t iLineHeight = 0, iMax;
   for (int32_t i = 0; i < iCount; i++) {
     pBreakPiece = rtfPieces.GetPtrAt(i);
     int32_t iFontHeight = FXSYS_round(pBreakPiece->m_iFontHeight *
                                       pBreakPiece->m_iVerticalScale / 100.0f);
     iMax = std::max(pBreakPiece->m_iFontSize, iFontHeight);
     if (i == 0) {
       iLineHeight = iMax;
     } else if (iLineHeight < iMax) {
       iLineHeight = iMax;
     }
   }
   rect.height = ((FX_FLOAT)iLineHeight) / 20.0f;
 }
 void CFX_RTFBreak::ClearBreakPieces() {
-  CFX_RTFLine* pRTFLine = GetRTFLine(TRUE);
+  CFX_RTFLine* pRTFLine = GetRTFLine(true);
   if (pRTFLine) {
-    pRTFLine->RemoveAll(TRUE);
+    pRTFLine->RemoveAll(true);
   }
   m_iReady = 0;
 }
 void CFX_RTFBreak::Reset() {
   m_eCharType = FX_CHARTYPE_Unknown;
-  m_RTFLine1.RemoveAll(TRUE);
-  m_RTFLine2.RemoveAll(TRUE);
+  m_RTFLine1.RemoveAll(true);
+  m_RTFLine2.RemoveAll(true);
 }
 int32_t CFX_RTFBreak::GetDisplayPos(const FX_RTFTEXTOBJ* pText,
                                     FXTEXT_CHARPOS* pCharPos,
-                                    FX_BOOL bCharCode,
+                                    bool bCharCode,
                                     CFX_WideString* pWSForms,
                                     FX_AdjustCharDisplayPos pAdjustPos) const {
   if (!pText || pText->iLength < 1) {
     return 0;
   }
   ASSERT(pText->pStr && pText->pWidths && pText->pFont && pText->pRect);
   const FX_WCHAR* pStr = pText->pStr;
   int32_t* pWidths = pText->pWidths;
   int32_t iLength = pText->iLength - 1;
   CFGAS_GEFont* pFont = pText->pFont;
   uint32_t dwStyles = pText->dwLayoutStyles;
   CFX_RectF rtText(*pText->pRect);
-  FX_BOOL bRTLPiece = FX_IsOdd(pText->iBidiLevel);
+  bool bRTLPiece = FX_IsOdd(pText->iBidiLevel);
   FX_FLOAT fFontSize = pText->fFontSize;
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   int32_t iAscent = pFont->GetAscent();
   int32_t iDescent = pFont->GetDescent();
   int32_t iMaxHeight = iAscent - iDescent;
   FX_FLOAT fFontHeight = fFontSize;
   FX_FLOAT fAscent = fFontHeight * (FX_FLOAT)iAscent / (FX_FLOAT)iMaxHeight;
   FX_FLOAT fDescent = fFontHeight * (FX_FLOAT)iDescent / (FX_FLOAT)iMaxHeight;
-  FX_BOOL bVerticalDoc = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalLayout) != 0;
-  FX_BOOL bVerticalChar = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalChars) != 0;
-  FX_BOOL bArabicNumber = (dwStyles & FX_RTFLAYOUTSTYLE_ArabicNumber) != 0;
-  FX_BOOL bMBCSCode = (dwStyles & FX_RTFLAYOUTSTYLE_MBCSCode) != 0;
+  bool bVerticalDoc = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalLayout) != 0;
+  bool bVerticalChar = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalChars) != 0;
+  bool bArabicNumber = (dwStyles & FX_RTFLAYOUTSTYLE_ArabicNumber) != 0;
+  bool bMBCSCode = (dwStyles & FX_RTFLAYOUTSTYLE_MBCSCode) != 0;
   int32_t iRotation = GetLineRotation(dwStyles) + pText->iCharRotation;
   int32_t iCharRotation;
   FX_WCHAR wch, wPrev = 0xFEFF, wNext, wForm;
   int32_t iWidth, iCharWidth, iCharHeight;
   FX_FLOAT fX, fY, fCharWidth, fCharHeight;
   int32_t iHorScale = pText->iHorizontalScale;
   int32_t iVerScale = pText->iVerticalScale;
-  FX_BOOL bEmptyChar;
+  bool bEmptyChar;
   uint32_t dwProps, dwCharType;
   fX = rtText.left;
   fY = rtText.top;
   if (bVerticalDoc) {
     fX += (rtText.width - fFontSize) / 2.0f;
     if (bRTLPiece) {
       fY = rtText.bottom();
     }
   } else {
     if (bRTLPiece) {
@@ skipping 18 matching lines @@
     }
     if (iWidth != 0) {
       iCharWidth = iWidth;
       if (iCharWidth < 0) {
         iCharWidth = -iCharWidth;
       }
       if (!bMBCSCode) {
         bEmptyChar = (dwCharType >= FX_CHARTYPE_Tab &&
                       dwCharType <= FX_CHARTYPE_Control);
       } else {
-        bEmptyChar = FALSE;
+        bEmptyChar = false;
       }
       if (!bEmptyChar) {
         iCount++;
       }
       if (pCharPos) {
         iCharWidth /= iFontSize;
         wForm = wch;
         if (!bMBCSCode) {
           if (dwCharType >= FX_CHARTYPE_ArabicAlef) {
             if (i < iLength) {
@@ skipping 46 matching lines @@
         fCharHeight = fFontSize * iCharHeight / 1000.0f;
         if (!bMBCSCode && bRTLPiece && dwCharType != FX_CHARTYPE_Combination) {
           if (bVerticalDoc) {
             fY -= fCharHeight;
           } else {
             fX -= fCharWidth;
           }
         }
         if (!bEmptyChar) {
           CFX_PointF ptOffset;
-          FX_BOOL bAdjusted = FALSE;
+          bool bAdjusted = false;
           if (pAdjustPos) {
             bAdjusted = pAdjustPos(wForm, bMBCSCode, pFont, fFontSize,
                                    bVerticalChar, ptOffset);
           }
           if (!bAdjusted && bVerticalChar && (dwProps & 0x00010000) != 0) {
             CFX_Rect rtBBox;
             rtBBox.Reset();
             if (pFont->GetCharBBox(wForm, rtBBox, bMBCSCode)) {
               ptOffset.x = fFontSize * (850 - rtBBox.right()) / 1000.0f;
               ptOffset.y = fFontSize * (1000 - rtBBox.height) / 2000.0f;
             }
           }
           pCharPos->m_OriginX = fX + ptOffset.x;
           pCharPos->m_OriginY = fY - ptOffset.y;
         }
         if (!bRTLPiece && dwCharType != FX_CHARTYPE_Combination) {
           if (bVerticalDoc) {
             fY += fCharHeight;
           } else {
             fX += fCharWidth;
           }
         }
         if (!bEmptyChar) {
-          pCharPos->m_bGlyphAdjust = TRUE;
+          pCharPos->m_bGlyphAdjust = true;
           if (bVerticalDoc) {
             if (iCharRotation == 0) {
               pCharPos->m_AdjustMatrix[0] = -1;
               pCharPos->m_AdjustMatrix[1] = 0;
               pCharPos->m_AdjustMatrix[2] = 0;
               pCharPos->m_AdjustMatrix[3] = 1;
               pCharPos->m_OriginY += fAscent * iVerScale / 100.0f;
             } else if (iCharRotation == 1) {
               pCharPos->m_AdjustMatrix[0] = 0;
               pCharPos->m_AdjustMatrix[1] = -1;
@@ skipping 60 matching lines @@
       }
     }
     if (iWidth > 0) {
       wPrev = wch;
     }
   }
   return iCount;
 }
 int32_t CFX_RTFBreak::GetCharRects(const FX_RTFTEXTOBJ* pText,
                                    CFX_RectFArray& rtArray,
-                                   FX_BOOL bCharBBox) const {
+                                   bool bCharBBox) const {
   if (!pText || pText->iLength < 1) {
     return 0;
   }
   ASSERT(pText->pStr && pText->pWidths && pText->pFont && pText->pRect);
   const FX_WCHAR* pStr = pText->pStr;
   int32_t* pWidths = pText->pWidths;
   int32_t iLength = pText->iLength;
   CFX_RectF rect(*pText->pRect);
-  FX_BOOL bRTLPiece = FX_IsOdd(pText->iBidiLevel);
+  bool bRTLPiece = FX_IsOdd(pText->iBidiLevel);
   FX_FLOAT fFontSize = pText->fFontSize;
   int32_t iFontSize = FXSYS_round(fFontSize * 20.0f);
   FX_FLOAT fScale = fFontSize / 1000.0f;
   CFGAS_GEFont* pFont = pText->pFont;
   if (!pFont) {
-    bCharBBox = FALSE;
+    bCharBBox = false;
   }
   CFX_Rect bbox;
   bbox.Set(0, 0, 0, 0);
   if (bCharBBox) {
     bCharBBox = pFont->GetBBox(bbox);
   }
   FX_FLOAT fLeft = std::max(0.0f, bbox.left * fScale);
   FX_FLOAT fHeight = FXSYS_fabs(bbox.height * fScale);
   rtArray.RemoveAll();
   rtArray.SetSize(iLength);
   uint32_t dwStyles = pText->dwLayoutStyles;
-  FX_BOOL bVertical = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalLayout) != 0;
-  FX_BOOL bSingleLine = (dwStyles & FX_RTFLAYOUTSTYLE_SingleLine) != 0;
-  FX_BOOL bCombText = (dwStyles & FX_TXTLAYOUTSTYLE_CombText) != 0;
+  bool bVertical = (dwStyles & FX_RTFLAYOUTSTYLE_VerticalLayout) != 0;
+  bool bSingleLine = (dwStyles & FX_RTFLAYOUTSTYLE_SingleLine) != 0;
+  bool bCombText = (dwStyles & FX_TXTLAYOUTSTYLE_CombText) != 0;
   FX_WCHAR wch, wLineBreakChar = pText->wLineBreakChar;
   int32_t iCharSize;
   FX_FLOAT fCharSize, fStart;
   if (bVertical) {
     fStart = bRTLPiece ? rect.bottom() : rect.top;
   } else {
     fStart = bRTLPiece ? rect.right() : rect.left;
   }
   for (int32_t i = 0; i < iLength; i++) {
     wch = *pStr++;
     iCharSize = *pWidths++;
     fCharSize = (FX_FLOAT)iCharSize / 20000.0f;
-    FX_BOOL bRet = (!bSingleLine && FX_IsCtrlCode(wch));
+    bool bRet = (!bSingleLine && FX_IsCtrlCode(wch));
     if (!(wch == L'\v' || wch == L'\f' || wch == 0x2028 || wch == 0x2029 ||
           (wLineBreakChar != 0xFEFF && wch == wLineBreakChar))) {
-      bRet = FALSE;
+      bRet = false;
     }
     if (bRet) {
       iCharSize = iFontSize * 500;
       fCharSize = fFontSize / 2.0f;
     }
     if (bVertical) {
       rect.top = fStart;
       if (bRTLPiece) {
         rect.top -= fCharSize;
         fStart -= fCharSize;
@@ skipping 82 matching lines @@
       iLength(0),
       pFont(nullptr),
       fFontSize(12.0f),
       dwLayoutStyles(0),
       iCharRotation(0),
       iBidiLevel(0),
       pRect(nullptr),
       wLineBreakChar(L'\n'),
       iHorizontalScale(100),
       iVerticalScale(100) {}