Remove FX_BOOL from xfa.

xfa/fde/cfde_txtedtpage.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/fde/cfde_txtedtpage.h"
 
 #include <algorithm>
 
@@ skipping 19 matching lines @@
 
 CFDE_TxtEdtPage::CFDE_TxtEdtPage(CFDE_TxtEdtEngine* pEngine, int32_t nPageIndex)
     : m_pEditEngine(pEngine),
       m_PieceMassArr(100),
       m_pBgnParag(nullptr),
       m_pEndParag(nullptr),
       m_nRefCount(0),
       m_nPageStart(-1),
       m_nCharCount(0),
       m_nPageIndex(nPageIndex),
-      m_bLoaded(FALSE) {
+      m_bLoaded(false) {
   FXSYS_memset(&m_rtPage, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageMargin, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageContents, 0, sizeof(CFX_RectF));
   FXSYS_memset(&m_rtPageCanvas, 0, sizeof(CFX_RectF));
 }
 
 CFDE_TxtEdtPage::~CFDE_TxtEdtPage() {
-  m_PieceMassArr.RemoveAll(TRUE);
+  m_PieceMassArr.RemoveAll(true);
 }
 
 CFDE_TxtEdtEngine* CFDE_TxtEdtPage::GetEngine() const {
   return m_pEditEngine;
 }
 
 FDE_VISUALOBJTYPE CFDE_TxtEdtPage::GetType() {
   return FDE_VISUALOBJ_Text;
 }
 
 void CFDE_TxtEdtPage::GetRect(FDE_TEXTEDITPIECE* hVisualObj, CFX_RectF& rt) {}
 
 int32_t CFDE_TxtEdtPage::GetCharRect(int32_t nIndex,
                                      CFX_RectF& rect,
-                                     FX_BOOL bBBox) const {
+                                     bool bBBox) const {
   ASSERT(m_nRefCount > 0);
   ASSERT(nIndex >= 0 && nIndex < m_nCharCount);
   if (m_nRefCount < 1) {
     return 0;
   }
   int32_t nCount = m_PieceMassArr.GetSize();
   for (int32_t i = 0; i < nCount; i++) {
     const FDE_TEXTEDITPIECE* pPiece = m_PieceMassArr.GetPtrAt(i);
     if (nIndex >= pPiece->nStart &&
         nIndex < (pPiece->nStart + pPiece->nCount)) {
       CFX_RectFArray rectArr;
       m_pTextSet->GetCharRects(pPiece, rectArr, bBBox);
       rect = rectArr[nIndex - pPiece->nStart];
       return pPiece->nBidiLevel;
     }
   }
   ASSERT(0);
   return 0;
 }
 
-int32_t CFDE_TxtEdtPage::GetCharIndex(const CFX_PointF& fPoint,
-                                      FX_BOOL& bBefore) {
-  FX_BOOL bVertical = m_pEditEngine->GetEditParams()->dwLayoutStyles &
-                      FDE_TEXTEDITLAYOUT_DocVertical;
+int32_t CFDE_TxtEdtPage::GetCharIndex(const CFX_PointF& fPoint, bool& bBefore) {
+  bool bVertical = m_pEditEngine->GetEditParams()->dwLayoutStyles &
+                   FDE_TEXTEDITLAYOUT_DocVertical;
   CFX_PointF ptF = fPoint;
   NormalizePt2Rect(ptF, m_rtPageContents, kTolerance);
   int32_t nCount = m_PieceMassArr.GetSize();
   CFX_RectF rtLine;
   int32_t nBgn = 0;
   int32_t nEnd = 0;
-  FX_BOOL bInLine = FALSE;
+  bool bInLine = false;
   int32_t i = 0;
   for (i = 0; i < nCount; i++) {
     const FDE_TEXTEDITPIECE* pPiece = m_PieceMassArr.GetPtrAt(i);
     if (!bInLine && (bVertical ? (pPiece->rtPiece.left <= ptF.x &&
                                   pPiece->rtPiece.right() > ptF.x)
                                : (pPiece->rtPiece.top <= ptF.y &&
                                   pPiece->rtPiece.bottom() > ptF.y))) {
       nBgn = nEnd = i;
       rtLine = pPiece->rtPiece;
-      bInLine = TRUE;
+      bInLine = true;
     } else if (bInLine) {
       if (bVertical ? (!(pPiece->rtPiece.left <= ptF.x &&
                          pPiece->rtPiece.right() > ptF.x))
                     : (pPiece->rtPiece.bottom() <= ptF.y ||
                        pPiece->rtPiece.top > ptF.y)) {
         nEnd = i - 1;
         break;
       } else {
         rtLine.Union(pPiece->rtPiece);
       }
     }
   }
   NormalizePt2Rect(ptF, rtLine, kTolerance);
   int32_t nCaret = 0;
   FDE_TEXTEDITPIECE* pPiece = nullptr;
   for (i = nBgn; i <= nEnd; i++) {
     pPiece = m_PieceMassArr.GetPtrAt(i);
     nCaret = m_nPageStart + pPiece->nStart;
     if (pPiece->rtPiece.Contains(ptF)) {
       CFX_RectFArray rectArr;
-      m_pTextSet->GetCharRects(pPiece, rectArr, FALSE);
+      m_pTextSet->GetCharRects(pPiece, rectArr, false);
       int32_t nRtCount = rectArr.GetSize();
       for (int32_t j = 0; j < nRtCount; j++) {
         if (rectArr[j].Contains(ptF)) {
           nCaret = m_nPageStart + pPiece->nStart + j;
           if (nCaret >= m_pEditEngine->GetTextBufLength()) {
-            bBefore = TRUE;
+            bBefore = true;
             return m_pEditEngine->GetTextBufLength();
           }
           FX_WCHAR wChar = m_pEditEngine->GetTextBuf()->GetCharByIndex(nCaret);
           if (wChar == L'\n' || wChar == L'\r') {
             if (wChar == L'\n') {
               if (m_pEditEngine->GetTextBuf()->GetCharByIndex(nCaret - 1) ==
                   L'\r') {
                 nCaret--;
               }
             }
-            bBefore = TRUE;
+            bBefore = true;
             return nCaret;
           }
           if (bVertical
                   ? (ptF.y > ((rectArr[j].top + rectArr[j].bottom()) / 2))
                   : (ptF.x > ((rectArr[j].left + rectArr[j].right()) / 2))) {
             bBefore = FX_IsOdd(pPiece->nBidiLevel);
           } else {
             bBefore = !FX_IsOdd(pPiece->nBidiLevel);
           }
           return nCaret;
         }
       }
     }
   }
-  bBefore = TRUE;
+  bBefore = true;
   return nCaret;
 }
 
 int32_t CFDE_TxtEdtPage::GetCharStart() const {
   return m_nPageStart;
 }
 
 int32_t CFDE_TxtEdtPage::GetCharCount() const {
   return m_nCharCount;
 }
 
 int32_t CFDE_TxtEdtPage::GetDisplayPos(const CFX_RectF& rtClip,
                                        FXTEXT_CHARPOS*& pCharPos,
                                        CFX_RectF* pBBox) const {
   pCharPos = FX_Alloc(FXTEXT_CHARPOS, m_nCharCount);
   int32_t nCharPosCount = 0;
   FDE_TEXTEDITPIECE* pPiece = nullptr;
   int32_t nVisualObjCount = m_PieceMassArr.GetSize();
   FXTEXT_CHARPOS* pos = pCharPos;
   CFX_RectF rtObj;
   for (int32_t i = 0; i < nVisualObjCount; i++) {
     pPiece = m_PieceMassArr.GetPtrAt(i);
     m_pTextSet->GetRect(pPiece, rtObj);
     if (!rtClip.IntersectWith(rtObj)) {
       continue;
     }
-    int32_t nCount = m_pTextSet->GetDisplayPos(pPiece, pos, FALSE);
+    int32_t nCount = m_pTextSet->GetDisplayPos(pPiece, pos, false);
     nCharPosCount += nCount;
     pos += nCount;
   }
   if ((nCharPosCount * 5) < (m_nCharCount << 2)) {
     FXTEXT_CHARPOS* pTemp = FX_Alloc(FXTEXT_CHARPOS, nCharPosCount);
     FXSYS_memcpy(pTemp, pCharPos, sizeof(FXTEXT_CHARPOS) * nCharPosCount);
     FX_Free(pCharPos);
     pCharPos = pTemp;
   }
   return nCharPosCount;
 }
 
 void CFDE_TxtEdtPage::CalcRangeRectArray(int32_t nStart,
                                          int32_t nCount,
                                          CFX_RectFArray& RectFArr) const {
   int32_t nPieceCount = m_PieceMassArr.GetSize();
   int32_t nEnd = nStart + nCount - 1;
-  FX_BOOL bInRange = FALSE;
+  bool bInRange = false;
   for (int32_t i = 0; i < nPieceCount; i++) {
     FDE_TEXTEDITPIECE* piece = m_PieceMassArr.GetPtrAt(i);
     if (!bInRange) {
       if (nStart >= piece->nStart && nStart < (piece->nStart + piece->nCount)) {
         int32_t nRangeEnd = piece->nCount - 1;
-        FX_BOOL bEnd = FALSE;
+        bool bEnd = false;
         if (nEnd >= piece->nStart && nEnd < (piece->nStart + piece->nCount)) {
           nRangeEnd = nEnd - piece->nStart;
-          bEnd = TRUE;
+          bEnd = true;
         }
         CFX_RectFArray rcArr;
-        m_pTextSet->GetCharRects(piece, rcArr, FALSE);
+        m_pTextSet->GetCharRects(piece, rcArr, false);
         CFX_RectF rectPiece = rcArr[nStart - piece->nStart];
         rectPiece.Union(rcArr[nRangeEnd]);
         RectFArr.Add(rectPiece);
         if (bEnd) {
           return;
         }
-        bInRange = TRUE;
+        bInRange = true;
       }
     } else {
       if (nEnd >= piece->nStart && nEnd < (piece->nStart + piece->nCount)) {
         CFX_RectFArray rcArr;
-        m_pTextSet->GetCharRects(piece, rcArr, FALSE);
+        m_pTextSet->GetCharRects(piece, rcArr, false);
         CFX_RectF rectPiece = rcArr[0];
         rectPiece.Union(rcArr[nEnd - piece->nStart]);
         RectFArr.Add(rectPiece);
         return;
       }
       RectFArr.Add(piece->rtPiece);
     }
   }
 }
 
 int32_t CFDE_TxtEdtPage::SelectWord(const CFX_PointF& fPoint, int32_t& nCount) {
   if (m_nRefCount < 0) {
     return -1;
   }
   CFDE_TxtEdtBuf* pBuf = m_pEditEngine->GetTextBuf();
-  FX_BOOL bBefore;
+  bool bBefore;
   int32_t nIndex = GetCharIndex(fPoint, bBefore);
   if (nIndex == m_pEditEngine->GetTextBufLength()) {
     nIndex = m_pEditEngine->GetTextBufLength() - 1;
   }
   if (nIndex < 0) {
     return -1;
   }
   std::unique_ptr<CFX_WordBreak> pIter(new CFX_WordBreak);
   pIter->Attach(new CFDE_TxtEdtBufIter(pBuf));
   pIter->SetAt(nIndex);
   nCount = pIter->GetWordLength();
   return pIter->GetWordPos();
 }
 
-FX_BOOL CFDE_TxtEdtPage::IsLoaded(const CFX_RectF* pClipBox) {
+bool CFDE_TxtEdtPage::IsLoaded(const CFX_RectF* pClipBox) {
   return m_bLoaded;
 }
 
 int32_t CFDE_TxtEdtPage::LoadPage(const CFX_RectF* pClipBox,
                                   IFX_Pause* pPause) {
   if (m_nRefCount > 0) {
     m_nRefCount++;
     return m_nRefCount;
   }
   CFDE_TxtEdtBuf* pBuf = m_pEditEngine->GetTextBuf();
@@ skipping 18 matching lines @@
       static_cast<CFDE_TxtEdtParag*>(m_pEditEngine->GetParag(nBgnParag));
   m_pBgnParag->LoadParag();
   m_pBgnParag->GetLineRange(nStartLine - nStartLineInParag, nPageStart, nTemp);
   nEndParag = m_pEditEngine->Line2Parag(nBgnParag, nStartLineInParag, nEndLine,
                                         nEndLineInParag);
   m_pEndParag =
       static_cast<CFDE_TxtEdtParag*>(m_pEditEngine->GetParag(nEndParag));
   m_pEndParag->LoadParag();
   m_pEndParag->GetLineRange(nEndLine - nEndLineInParag, nPageEnd, nTemp);
   nPageEnd += (nTemp - 1);
-  FX_BOOL bVertial = pParams->dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical;
-  FX_BOOL bLineReserve =
+  bool bVertial = pParams->dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical;
+  bool bLineReserve =
       !!(pParams->dwLayoutStyles & FDE_TEXTEDITLAYOUT_LineReserve);
   FX_FLOAT fLineStart =
       bVertial
           ? (bLineReserve ? (pParams->fPlateWidth - pParams->fLineSpace) : 0.0f)
           : 0.0f;
   FX_FLOAT fLineStep =
       (bVertial && bLineReserve) ? (-pParams->fLineSpace) : pParams->fLineSpace;
   FX_FLOAT fLinePos = fLineStart;
   if (!m_pTextSet)
     m_pTextSet.reset(new CFDE_TxtEdtTextSet(this));
 
-  m_PieceMassArr.RemoveAll(TRUE);
+  m_PieceMassArr.RemoveAll(true);
   uint32_t dwBreakStatus = FX_TXTBREAK_None;
   int32_t nPieceStart = 0;
 
   m_CharWidths.resize(nPageEnd - nPageStart + 1, 0);
   pBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
   pBreak->ClearBreakPieces();
   m_nPageStart = nPageStart;
   m_nCharCount = nPageEnd - nPageStart + 1;
-  FX_BOOL bReload = FALSE;
+  bool bReload = false;
   FX_FLOAT fDefCharWidth = 0;
   std::unique_ptr<IFX_CharIter> pIter(m_pIter->Clone());
   pIter->SetAt(nPageStart);
   m_pIter->SetAt(nPageStart);
-  FX_BOOL bFirstPiece = TRUE;
+  bool bFirstPiece = true;
   do {
     if (bReload) {
       dwBreakStatus = pBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
     } else {
       FX_WCHAR wAppend = pIter->GetChar();
       dwBreakStatus = pBreak->AppendChar(wAppend);
     }
     if (pIter->GetAt() == nPageEnd && dwBreakStatus < FX_TXTBREAK_LineBreak) {
       dwBreakStatus = pBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
     }
@@ skipping 40 matching lines @@
               (FX_FLOAT)pPiece->m_iWidth / 20000.0f + fParaBreakWidth;
         } else {
           TxtEdtPiece.rtPiece.left = (FX_FLOAT)pPiece->m_iStartPos / 20000.0f;
           TxtEdtPiece.rtPiece.top = fLinePos;
           TxtEdtPiece.rtPiece.width =
               (FX_FLOAT)pPiece->m_iWidth / 20000.0f + fParaBreakWidth;
           TxtEdtPiece.rtPiece.height = pParams->fLineSpace;
         }
         if (bFirstPiece) {
           m_rtPageContents = TxtEdtPiece.rtPiece;
-          bFirstPiece = FALSE;
+          bFirstPiece = false;
         } else {
           m_rtPageContents.Union(TxtEdtPiece.rtPiece);
         }
         nPieceStart += TxtEdtPiece.nCount;
         m_PieceMassArr.Add(TxtEdtPiece);
         for (int32_t k = 0; k < TxtEdtPiece.nCount; k++) {
           CFX_Char* ptc = pPiece->GetCharPtr(k);
           m_CharWidths[TxtEdtPiece.nStart + k] = ptc->m_iCharWidth;
         }
       }
       fLinePos += fLineStep;
       pBreak->ClearBreakPieces();
     }
     if (pIter->GetAt() == nPageEnd && dwBreakStatus == FX_TXTBREAK_LineBreak) {
-      bReload = TRUE;
-      pIter->Next(TRUE);
+      bReload = true;
+      pIter->Next(true);
     }
-  } while (pIter->Next(FALSE) && (pIter->GetAt() <= nPageEnd));
+  } while (pIter->Next(false) && (pIter->GetAt() <= nPageEnd));
   if (m_rtPageContents.left != 0) {
     FX_FLOAT fDelta = 0.0f;
     if (m_rtPageContents.width < pParams->fPlateWidth) {
       if (pParams->dwAlignment & FDE_TEXTEDITALIGN_Right) {
         fDelta = pParams->fPlateWidth - m_rtPageContents.width;
       } else if (pParams->dwAlignment & FDE_TEXTEDITALIGN_Center) {
         if ((pParams->dwLayoutStyles & FDE_TEXTEDITLAYOUT_CombText) &&
             m_nCharCount > 1) {
           int32_t nCount = m_nCharCount - 1;
           int32_t n = (m_pEditEngine->m_nLimit - nCount) / 2;
@@ skipping 12 matching lines @@
     m_rtPageContents.Offset(-fOffset, 0.0f);
   }
   if (m_pEditEngine->GetEditParams()->dwLayoutStyles &
       FDE_TEXTEDITLAYOUT_LastLineHeight) {
     m_rtPageContents.height -= pParams->fLineSpace - pParams->fFontSize;
     int32_t nCount = m_PieceMassArr.GetSize();
     FDE_TEXTEDITPIECE* pPiece = m_PieceMassArr.GetPtrAt(nCount - 1);
     pPiece->rtPiece.height = pParams->fFontSize;
   }
   m_nRefCount = 1;
-  m_bLoaded = TRUE;
+  m_bLoaded = true;
   return 0;
 }
 
 void CFDE_TxtEdtPage::UnloadPage(const CFX_RectF* pClipBox) {
   ASSERT(m_nRefCount > 0);
   m_nRefCount--;
   if (m_nRefCount != 0)
     return;
 
-  m_PieceMassArr.RemoveAll(FALSE);
+  m_PieceMassArr.RemoveAll(false);
   m_pTextSet.reset();
   m_CharWidths.clear();
   if (m_pBgnParag) {
     m_pBgnParag->UnloadParag();
     m_pBgnParag = nullptr;
   }
   if (m_pEndParag) {
     m_pEndParag->UnloadParag();
     m_pEndParag = nullptr;
   }
@@ skipping 53 matching lines @@
     ptF.x = rtF.left;
   } else if (ptF.x >= rtF.right()) {
     ptF.x = rtF.right() - fTolerance;
   }
   if (ptF.y < rtF.top) {
     ptF.y = rtF.top;
   } else if (ptF.y >= rtF.bottom()) {
     ptF.y = rtF.bottom() - fTolerance;
   }
 }