Remove FX_BOOL from core

core/fpdftext/cpdf_textpage.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 "core/fpdftext/cpdf_textpage.h"
 
 #include <algorithm>
 #include <utility>
@@ skipping 652 matching lines @@
 
 void CPDF_TextPage::AddCharInfoByRLDirection(FX_WCHAR wChar,
                                              PAGECHAR_INFO info) {
   if (IsControlChar(info)) {
     info.m_Index = -1;
     m_CharList.push_back(info);
     return;
   }
 
   info.m_Index = m_TextBuf.GetLength();
-  wChar = FX_GetMirrorChar(wChar, TRUE, FALSE);
+  wChar = FX_GetMirrorChar(wChar, true, false);
   FX_WCHAR* pDst = nullptr;
   FX_STRSIZE nCount = Unicode_GetNormalization(wChar, pDst);
   if (nCount >= 1) {
     pDst = FX_Alloc(FX_WCHAR, nCount);
     Unicode_GetNormalization(wChar, pDst);
     for (int nIndex = 0; nIndex < nCount; nIndex++) {
       PAGECHAR_INFO info2 = info;
       info2.m_Unicode = pDst[nIndex];
       info2.m_Flag = FPDFTEXT_CHAR_PIECE;
       m_TextBuf.AppendChar(info2.m_Unicode);
@@ skipping 261 matching lines @@
     std::swap(m_TempCharList[i], m_TempCharList[j]);
     std::swap(m_TempCharList[i].m_Index, m_TempCharList[j].m_Index);
   }
   FX_WCHAR* pTempBuffer = m_TempTextBuf.GetBuffer();
   i = iBufStartAppend;
   j = m_TempTextBuf.GetLength() - 1;
   for (; i < j; i++, j--)
     std::swap(pTempBuffer[i], pTempBuffer[j]);
 }
 
-FX_BOOL CPDF_TextPage::IsRightToLeft(const CPDF_TextObject* pTextObj,
-                                     const CPDF_Font* pFont,
-                                     int nItems) const {
+bool CPDF_TextPage::IsRightToLeft(const CPDF_TextObject* pTextObj,
+                                  const CPDF_Font* pFont,
+                                  int nItems) const {
   CFX_WideString str;
   for (int32_t i = 0; i < nItems; i++) {
     CPDF_TextObjectItem item;
     pTextObj->GetItemInfo(i, &item);
     if (item.m_CharCode == static_cast<uint32_t>(-1))
       continue;
     CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
     FX_WCHAR wChar = wstrItem.GetAt(0);
     if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode)
       wChar = (FX_WCHAR)item.m_CharCode;
@@ skipping 84 matching lines @@
     ProcessMarkedContent(Obj);
     m_pPreTextObj = pTextObj;
     m_perMatrix = formMatrix;
     return;
   }
   m_pPreTextObj = pTextObj;
   m_perMatrix = formMatrix;
   int nItems = pTextObj->CountItems();
   FX_FLOAT baseSpace = CalculateBaseSpace(pTextObj, matrix);
 
-  const FX_BOOL bR2L = IsRightToLeft(pTextObj, pFont, nItems);
-  const FX_BOOL bIsBidiAndMirrorInverse =
+  const bool bR2L = IsRightToLeft(pTextObj, pFont, nItems);
+  const bool bIsBidiAndMirrorInverse =
       bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
   int32_t iBufStartAppend = m_TempTextBuf.GetLength();
   int32_t iCharListStartAppend =
       pdfium::CollectionSize<int32_t>(m_TempCharList);
 
   FX_FLOAT spacing = 0;
   for (int i = 0; i < nItems; i++) {
     CPDF_TextObjectItem item;
     PAGECHAR_INFO charinfo;
     charinfo.m_OriginX = 0;
@@ skipping 160 matching lines @@
   v.Normalize();
   if (v.y <= 0.0872f)
     return v.x <= 0.0872f ? m_TextlineDir : TextOrientation::Horizontal;
 
   if (v.x <= 0.0872f)
     return TextOrientation::Vertical;
 
   return m_TextlineDir;
 }
 
-FX_BOOL CPDF_TextPage::IsHyphen(FX_WCHAR curChar) {
+bool CPDF_TextPage::IsHyphen(FX_WCHAR curChar) {
   CFX_WideString strCurText = m_TempTextBuf.MakeString();
   if (strCurText.IsEmpty())
     strCurText = m_TextBuf.AsStringC();
   FX_STRSIZE nCount = strCurText.GetLength();
   int nIndex = nCount - 1;
   FX_WCHAR wcTmp = strCurText.GetAt(nIndex);
   while (wcTmp == 0x20 && nIndex <= nCount - 1 && nIndex >= 0)
     wcTmp = strCurText.GetAt(--nIndex);
   if (0x2D == wcTmp || 0xAD == wcTmp) {
     if (--nIndex > 0) {
       FX_WCHAR preChar = strCurText.GetAt((nIndex));
       if (((preChar >= L'A' && preChar <= L'Z') ||
            (preChar >= L'a' && preChar <= L'z')) &&
           ((curChar >= L'A' && curChar <= L'Z') ||
            (curChar >= L'a' && curChar <= L'z'))) {
-        return TRUE;
+        return true;
       }
     }
     const PAGECHAR_INFO* preInfo;
     if (!m_TempCharList.empty())
       preInfo = &m_TempCharList.back();
     else if (!m_CharList.empty())
       preInfo = &m_CharList.back();
     else
-      return FALSE;
+      return false;
     if (FPDFTEXT_CHAR_PIECE == preInfo->m_Flag &&
         (0xAD == preInfo->m_Unicode || 0x2D == preInfo->m_Unicode)) {
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
 
 CPDF_TextPage::GenerateCharacter CPDF_TextPage::ProcessInsertObject(
     const CPDF_TextObject* pObj,
     const CFX_Matrix& formMatrix) {
   FindPreviousTextObject();
   TextOrientation WritingMode = GetTextObjectWritingMode(pObj);
   if (WritingMode == TextOrientation::Unknown)
     WritingMode = GetTextObjectWritingMode(m_pPreTextObj);
 
@@ skipping 57 matching lines @@
   bool bNewline = false;
   if (WritingMode == TextOrientation::Horizontal) {
     CFX_FloatRect rect1(m_pPreTextObj->m_Left, pObj->m_Bottom,
                         m_pPreTextObj->m_Right, pObj->m_Top);
     CFX_FloatRect rect2(m_pPreTextObj->m_Left, m_pPreTextObj->m_Bottom,
                         m_pPreTextObj->m_Right, m_pPreTextObj->m_Top);
     CFX_FloatRect rect3 = rect1;
     rect1.Intersect(rect2);
     if ((rect1.IsEmpty() && rect2.Height() > 5 && rect3.Height() > 5) ||
         ((y > threshold * 2 || y < threshold * -3) &&
-         (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : TRUE))) {
+         (FXSYS_fabs(y) < 1 ? FXSYS_fabs(x) < FXSYS_fabs(y) : true))) {
       bNewline = true;
       if (nItem > 1) {
         CPDF_TextObjectItem tempItem;
         m_pPreTextObj->GetItemInfo(0, &tempItem);
         CFX_Matrix m;
         m_pPreTextObj->GetTextMatrix(&m);
         if (PrevItem.m_OriginX > tempItem.m_OriginX &&
             m_DisplayMatrix.a > 0.9 && m_DisplayMatrix.b < 0.1 &&
             m_DisplayMatrix.c < 0.1 && m_DisplayMatrix.d < -0.9 && m.b < 0.1 &&
             m.c < 0.1) {
@@ skipping 57 matching lines @@
         return GenerateCharacter::Space;
       if ((x - last_pos - last_width) > this_width ||
           (x - last_pos - this_width) > last_width) {
         return GenerateCharacter::Space;
       }
     }
   }
   return GenerateCharacter::None;
 }
 
-FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
-                                        CPDF_TextObject* pTextObj2) {
+bool CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
+                                     CPDF_TextObject* pTextObj2) {
   if (!pTextObj1 || !pTextObj2)
-    return FALSE;
+    return false;
   CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom,
                          pTextObj2->m_Right, pTextObj2->m_Top);
   CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom,
                          pTextObj1->m_Right, pTextObj1->m_Top);
   if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty()) {
     FX_FLOAT dbXdif = FXSYS_fabs(rcPreObj.left - rcCurObj.left);
     size_t nCount = m_CharList.size();
     if (nCount >= 2) {
       PAGECHAR_INFO perCharTemp = m_CharList[nCount - 2];
       FX_FLOAT dbSpace = perCharTemp.m_CharBox.Width();
       if (dbXdif > dbSpace)
-        return FALSE;
+        return false;
     }
   }
   if (!rcPreObj.IsEmpty() || !rcCurObj.IsEmpty()) {
     rcPreObj.Intersect(rcCurObj);
     if (rcPreObj.IsEmpty())
-      return FALSE;
+      return false;
     if (FXSYS_fabs(rcPreObj.Width() - rcCurObj.Width()) >
         rcCurObj.Width() / 2) {
-      return FALSE;
+      return false;
     }
     if (pTextObj2->GetFontSize() != pTextObj1->GetFontSize())
-      return FALSE;
+      return false;
   }
   int nPreCount = pTextObj2->CountItems();
   int nCurCount = pTextObj1->CountItems();
   if (nPreCount != nCurCount)
-    return FALSE;
+    return false;
   // If both objects have no items, consider them same.
   if (!nPreCount)
-    return TRUE;
+    return true;
 
   CPDF_TextObjectItem itemPer = {0, 0.0f, 0.0f};
   CPDF_TextObjectItem itemCur = {0, 0.0f, 0.0f};
   for (int i = 0; i < nPreCount; i++) {
     pTextObj2->GetItemInfo(i, &itemPer);
     pTextObj1->GetItemInfo(i, &itemCur);
     if (itemCur.m_CharCode != itemPer.m_CharCode)
-      return FALSE;
+      return false;
   }
   if (FXSYS_fabs(pTextObj1->GetPosX() - pTextObj2->GetPosX()) >
           GetCharWidth(itemPer.m_CharCode, pTextObj2->GetFont()) *
               pTextObj2->GetFontSize() / 1000 * 0.9 ||
       FXSYS_fabs(pTextObj1->GetPosY() - pTextObj2->GetPosY()) >
           std::max(std::max(rcPreObj.Height(), rcPreObj.Width()),
                    pTextObj2->GetFontSize()) /
               8) {
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_TextPage::IsSameAsPreTextObject(
+bool CPDF_TextPage::IsSameAsPreTextObject(
     CPDF_TextObject* pTextObj,
     const CPDF_PageObjectList* pObjList,
     CPDF_PageObjectList::const_iterator iter) {
   int i = 0;
   while (i < 5 && iter != pObjList->begin()) {
     --iter;
     CPDF_PageObject* pOtherObj = iter->get();
     if (pOtherObj == pTextObj || !pOtherObj->IsText())
       continue;
     if (IsSameTextObject(pOtherObj->AsText(), pTextObj))
-      return TRUE;
+      return true;
     ++i;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info) {
+bool CPDF_TextPage::GenerateCharInfo(FX_WCHAR unicode, PAGECHAR_INFO& info) {
   const PAGECHAR_INFO* preChar;
   if (!m_TempCharList.empty())
     preChar = &m_TempCharList.back();
   else if (!m_CharList.empty())
     preChar = &m_CharList.back();
   else
-    return FALSE;
+    return false;
   info.m_Index = m_TextBuf.GetLength();
   info.m_Unicode = unicode;
   info.m_pTextObj = nullptr;
   info.m_CharCode = CPDF_Font::kInvalidCharCode;
   info.m_Flag = FPDFTEXT_CHAR_GENERATED;
   int preWidth = 0;
   if (preChar->m_pTextObj && preChar->m_CharCode != -1) {
     preWidth =
         GetCharWidth(preChar->m_CharCode, preChar->m_pTextObj->GetFont());
   }
 
   FX_FLOAT fFontSize = preChar->m_pTextObj ? preChar->m_pTextObj->GetFontSize()
                                            : preChar->m_CharBox.Height();
   if (!fFontSize)
     fFontSize = kDefaultFontSize;
 
   info.m_OriginX = preChar->m_OriginX + preWidth * (fFontSize) / 1000;
   info.m_OriginY = preChar->m_OriginY;
   info.m_CharBox = CFX_FloatRect(info.m_OriginX, info.m_OriginY, info.m_OriginX,
                                  info.m_OriginY);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1,
-                                       const CFX_FloatRect& rect2) {
+bool CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1,
+                                    const CFX_FloatRect& rect2) {
   CFX_FloatRect rect = rect1;
   rect.Intersect(rect2);
   return !rect.IsEmpty();
 }