Remove FX_BOOL from xfa.

xfa/fde/cfde_txtedtengine.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_txtedtengine.h"
 
 #include "xfa/fde/cfde_txtedtbuf.h"
 #include "xfa/fde/cfde_txtedtbufiter.h"
@@ skipping 18 matching lines @@
       fPlateHeight(0),
       nLineCount(0),
       dwLayoutStyles(0),
       dwAlignment(0),
       dwMode(0),
       pFont(nullptr),
       fFontSize(10.0f),
       dwFontColor(0xff000000),
       fLineSpace(10.0f),
       fTabWidth(36),
-      bTabEquidistant(FALSE),
+      bTabEquidistant(false),
       wDefChar(0xFEFF),
       wLineBreakChar('\n'),
       nCharRotation(0),
       nLineEnd(0),
       nHorzScale(100),
       fCharSpace(0),
       pEventSink(nullptr) {}
 
 FDE_TXTEDT_TEXTCHANGE_INFO::FDE_TXTEDT_TEXTCHANGE_INFO() {}
 
 FDE_TXTEDT_TEXTCHANGE_INFO::~FDE_TXTEDT_TEXTCHANGE_INFO() {}
 
 CFDE_TxtEdtEngine::CFDE_TxtEdtEngine()
     : m_pTxtBuf(new CFDE_TxtEdtBuf()),
       m_nPageLineCount(20),
       m_nLineCount(0),
       m_nAnchorPos(-1),
       m_nLayoutPos(0),
       m_fCaretPosReserve(0.0),
       m_nCaret(0),
-      m_bBefore(TRUE),
+      m_bBefore(true),
       m_nCaretPage(0),
       m_dwFindFlags(0),
-      m_bLock(FALSE),
+      m_bLock(false),
       m_nLimit(0),
       m_wcAliasChar(L'*'),
       m_nFirstLineEnd(FDE_TXTEDIT_LINEEND_Auto),
-      m_bAutoLineEnd(TRUE),
+      m_bAutoLineEnd(true),
       m_wLineEnd(kUnicodeParagraphSeparator) {
   FXSYS_memset(&m_rtCaret, 0, sizeof(CFX_RectF));
   m_bAutoLineEnd = (m_Param.nLineEnd == FDE_TXTEDIT_LINEEND_Auto);
 }
 
 CFDE_TxtEdtEngine::~CFDE_TxtEdtEngine() {
   RemoveAllParags();
   RemoveAllPages();
   m_Param.pEventSink = nullptr;
   ClearSelection();
@@ skipping 25 matching lines @@
     return nullptr;
   }
   return m_PagePtrArray[nIndex];
 }
 
 void CFDE_TxtEdtEngine::SetTextByStream(IFX_Stream* pStream) {
   ResetEngine();
   int32_t nIndex = 0;
   if (pStream && pStream->GetLength()) {
     int32_t nStreamLength = pStream->GetLength();
-    FX_BOOL bValid = TRUE;
+    bool bValid = true;
     if (m_nLimit > 0 && nStreamLength > m_nLimit) {
-      bValid = FALSE;
+      bValid = false;
     }
-    FX_BOOL bPreIsCR = FALSE;
+    bool bPreIsCR = false;
     if (bValid) {
       uint8_t bom[4];
       int32_t nPos = pStream->GetBOM(bom);
       pStream->Seek(FX_STREAMSEEK_Begin, nPos);
       int32_t nPlateSize = std::min(nStreamLength, m_pTxtBuf->GetChunkSize());
       FX_WCHAR* lpwstr = FX_Alloc(FX_WCHAR, nPlateSize);
-      FX_BOOL bEos = false;
+      bool bEos = false;
       while (!bEos) {
         int32_t nRead = pStream->ReadString(lpwstr, nPlateSize, bEos);
         bPreIsCR = ReplaceParagEnd(lpwstr, nRead, bPreIsCR);
         m_pTxtBuf->Insert(nIndex, lpwstr, nRead);
         nIndex += nRead;
       }
       FX_Free(lpwstr);
     }
   }
   m_pTxtBuf->Insert(nIndex, &m_wLineEnd, 1);
   RebuildParagraphs();
 }
 
 void CFDE_TxtEdtEngine::SetText(const CFX_WideString& wsText) {
   ResetEngine();
   int32_t nLength = wsText.GetLength();
   if (nLength > 0) {
     CFX_WideString wsTemp;
     FX_WCHAR* lpBuffer = wsTemp.GetBuffer(nLength);
     FXSYS_memcpy(lpBuffer, wsText.c_str(), nLength * sizeof(FX_WCHAR));
-    ReplaceParagEnd(lpBuffer, nLength, FALSE);
+    ReplaceParagEnd(lpBuffer, nLength, false);
     wsTemp.ReleaseBuffer(nLength);
     if (m_nLimit > 0 && nLength > m_nLimit) {
       wsTemp.Delete(m_nLimit, nLength - m_nLimit);
       nLength = m_nLimit;
     }
     m_pTxtBuf->SetText(wsTemp);
   }
   m_pTxtBuf->Insert(nLength, &m_wLineEnd, 1);
   RebuildParagraphs();
 }
@@ skipping 22 matching lines @@
   return m_nCaret;
 }
 
 int32_t CFDE_TxtEdtEngine::GetCaretPos() const {
   if (IsLocked()) {
     return 0;
   }
   return m_nCaret + (m_bBefore ? 0 : 1);
 }
 
-int32_t CFDE_TxtEdtEngine::SetCaretPos(int32_t nIndex, FX_BOOL bBefore) {
+int32_t CFDE_TxtEdtEngine::SetCaretPos(int32_t nIndex, bool bBefore) {
   if (IsLocked()) {
     return 0;
   }
   ASSERT(nIndex >= 0 && nIndex <= GetTextBufLength());
   if (m_PagePtrArray.GetSize() <= m_nCaretPage) {
     return 0;
   }
   m_bBefore = bBefore;
   m_nCaret = nIndex;
   MovePage2Char(m_nCaret);
   GetCaretRect(m_rtCaret, m_nCaretPage, m_nCaret, m_bBefore);
   if (!m_bBefore) {
     m_nCaret++;
-    m_bBefore = TRUE;
+    m_bBefore = true;
   }
   m_fCaretPosReserve = (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical)
                            ? m_rtCaret.top
                            : m_rtCaret.left;
   m_Param.pEventSink->On_CaretChanged(this, m_nCaretPage, 0);
   m_nAnchorPos = -1;
   return m_nCaret;
 }
 
 int32_t CFDE_TxtEdtEngine::MoveCaretPos(FDE_TXTEDTMOVECARET eMoveCaret,
-                                        FX_BOOL bShift,
-                                        FX_BOOL bCtrl) {
+                                        bool bShift,
+                                        bool bCtrl) {
   if (IsLocked()) {
     return 0;
   }
   if (m_PagePtrArray.GetSize() <= m_nCaretPage) {
     return 0;
   }
-  FX_BOOL bSelChange = FALSE;
+  bool bSelChange = false;
   if (IsSelect()) {
     ClearSelection();
-    bSelChange = TRUE;
+    bSelChange = true;
   }
   if (bShift) {
     if (m_nAnchorPos == -1) {
       m_nAnchorPos = m_nCaret;
     }
   } else {
     m_nAnchorPos = -1;
   }
-  FX_BOOL bVertical = m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical;
+  bool bVertical = m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical;
   switch (eMoveCaret) {
     case MC_Left: {
       if (bVertical) {
         CFX_PointF ptCaret;
         if (MoveUp(ptCaret)) {
           UpdateCaretIndex(ptCaret);
         }
       } else {
-        FX_BOOL bBefore = TRUE;
+        bool bBefore = true;
         int32_t nIndex = MoveBackward(bBefore);
         if (nIndex >= 0) {
           UpdateCaretRect(nIndex, bBefore);
         }
       }
     } break;
     case MC_Right: {
       if (bVertical) {
         CFX_PointF ptCaret;
         if (MoveDown(ptCaret)) {
           UpdateCaretIndex(ptCaret);
         }
       } else {
-        FX_BOOL bBefore = TRUE;
+        bool bBefore = true;
         int32_t nIndex = MoveForward(bBefore);
         if (nIndex >= 0) {
           UpdateCaretRect(nIndex, bBefore);
         }
       }
     } break;
     case MC_Up: {
       if (bVertical) {
-        FX_BOOL bBefore = TRUE;
+        bool bBefore = true;
         int32_t nIndex = MoveBackward(bBefore);
         if (nIndex >= 0) {
           UpdateCaretRect(nIndex, bBefore);
         }
       } else {
         CFX_PointF ptCaret;
         if (MoveUp(ptCaret)) {
           UpdateCaretIndex(ptCaret);
         }
       }
     } break;
     case MC_Down: {
       if (bVertical) {
-        FX_BOOL bBefore = TRUE;
+        bool bBefore = true;
         int32_t nIndex = MoveForward(bBefore);
         if (nIndex >= 0) {
           UpdateCaretRect(nIndex, bBefore);
         }
       } else {
         CFX_PointF ptCaret;
         if (MoveDown(ptCaret)) {
           UpdateCaretIndex(ptCaret);
         }
       }
@@ skipping 32 matching lines @@
                 FXSYS_abs(m_nAnchorPos - m_nCaret));
     m_Param.pEventSink->On_SelChanged(this);
   }
   if (bSelChange) {
     m_Param.pEventSink->On_SelChanged(this);
   }
   return m_nCaret;
 }
 
 void CFDE_TxtEdtEngine::Lock() {
-  m_bLock = TRUE;
+  m_bLock = true;
 }
 
 void CFDE_TxtEdtEngine::Unlock() {
-  m_bLock = FALSE;
+  m_bLock = false;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::IsLocked() const {
+bool CFDE_TxtEdtEngine::IsLocked() const {
   return m_bLock;
 }
 
 int32_t CFDE_TxtEdtEngine::Insert(int32_t nStart,
                                   const FX_WCHAR* lpText,
                                   int32_t nLength) {
   if (IsLocked()) {
     return FDE_TXTEDT_MODIFY_RET_F_Locked;
   }
   CFX_WideString wsTemp;
   FX_WCHAR* lpBuffer = wsTemp.GetBuffer(nLength);
   FXSYS_memcpy(lpBuffer, lpText, nLength * sizeof(FX_WCHAR));
-  ReplaceParagEnd(lpBuffer, nLength, FALSE);
+  ReplaceParagEnd(lpBuffer, nLength, false);
   wsTemp.ReleaseBuffer(nLength);
-  FX_BOOL bPart = FALSE;
+  bool bPart = false;
   if (m_nLimit > 0) {
     int32_t nTotalLength = GetTextBufLength();
     int32_t nCount = m_SelRangePtrArr.GetSize();
     for (int32_t i = 0; i < nCount; i++) {
       FDE_TXTEDTSELRANGE* lpSelRange = m_SelRangePtrArr.GetAt(i);
       nTotalLength -= lpSelRange->nCount;
     }
     int32_t nExpectLength = nTotalLength + nLength;
     if (nTotalLength == m_nLimit) {
       return FDE_TXTEDT_MODIFY_RET_F_Full;
     }
     if (nExpectLength > m_nLimit) {
       nLength -= (nExpectLength - m_nLimit);
-      bPart = TRUE;
+      bPart = true;
     }
   }
   if ((m_Param.dwMode & FDE_TEXTEDITMODE_LimitArea_Vert) ||
       (m_Param.dwMode & FDE_TEXTEDITMODE_LimitArea_Horz)) {
     int32_t nTemp = nLength;
     if (m_Param.dwMode & FDE_TEXTEDITMODE_Password) {
       CFX_WideString wsText;
       while (nLength > 0) {
         GetPreInsertText(wsText, m_nCaret, lpBuffer, nLength);
         int32_t nTotal = wsText.GetLength();
@@ skipping 14 matching lines @@
         if (IsFitArea(wsText)) {
           break;
         }
         nLength--;
       }
     }
     if (nLength == 0) {
       return FDE_TXTEDT_MODIFY_RET_F_Full;
     }
     if (nLength < nTemp) {
-      bPart = TRUE;
+      bPart = true;
     }
   }
   if (m_Param.dwMode & FDE_TEXTEDITMODE_Validate) {
     CFX_WideString wsText;
     GetPreInsertText(wsText, m_nCaret, lpBuffer, nLength);
     if (!m_Param.pEventSink->On_Validate(this, wsText)) {
       return FDE_TXTEDT_MODIFY_RET_F_Invalidate;
     }
   }
   if (IsSelect()) {
     DeleteSelect();
   }
   if (!(m_Param.dwMode & FDE_TEXTEDITMODE_NoRedoUndo))
     m_Param.pEventSink->On_AddDoRecord(
         this,
         new CFDE_TxtEdtDoRecord_Insert(this, m_nCaret, lpBuffer, nLength));
 
   GetText(m_ChangeInfo.wsPrevText, 0);
   Inner_Insert(m_nCaret, lpBuffer, nLength);
   m_ChangeInfo.nChangeType = FDE_TXTEDT_TEXTCHANGE_TYPE_Insert;
   m_ChangeInfo.wsInsert = CFX_WideString(lpBuffer, nLength);
   nStart = m_nCaret;
   nStart += nLength;
   FX_WCHAR wChar = m_pTxtBuf->GetCharByIndex(nStart - 1);
-  FX_BOOL bBefore = TRUE;
+  bool bBefore = true;
   if (wChar != L'\n' && wChar != L'\r') {
     nStart--;
-    bBefore = FALSE;
+    bBefore = false;
   }
   SetCaretPos(nStart, bBefore);
   m_Param.pEventSink->On_TextChanged(this, m_ChangeInfo);
   return bPart ? FDE_TXTEDT_MODIFY_RET_S_Part : FDE_TXTEDT_MODIFY_RET_S_Normal;
 }
 
-int32_t CFDE_TxtEdtEngine::Delete(int32_t nStart, FX_BOOL bBackspace) {
+int32_t CFDE_TxtEdtEngine::Delete(int32_t nStart, bool bBackspace) {
   if (IsLocked()) {
     return FDE_TXTEDT_MODIFY_RET_F_Locked;
   }
   if (IsSelect()) {
     DeleteSelect();
     return FDE_TXTEDT_MODIFY_RET_S_Normal;
   }
 
   int32_t nCount = 1;
   if (bBackspace) {
@@ skipping 51 matching lines @@
   }
   if (m_Param.dwMode & FDE_TEXTEDITMODE_Validate) {
     CFX_WideString wsText;
     GetPreDeleteText(wsText, nStart, nCount);
     if (!m_Param.pEventSink->On_Validate(this, wsText)) {
       return FDE_TXTEDT_MODIFY_RET_F_Invalidate;
     }
   }
   DeleteRange_DoRecord(nStart, nCount);
   m_Param.pEventSink->On_TextChanged(this, m_ChangeInfo);
-  SetCaretPos(nStart, TRUE);
+  SetCaretPos(nStart, true);
   return FDE_TXTEDT_MODIFY_RET_S_Normal;
 }
 
 int32_t CFDE_TxtEdtEngine::Replace(int32_t nStart,
                                    int32_t nLength,
                                    const CFX_WideString& wsReplace) {
   if (IsLocked()) {
     return FDE_TXTEDT_MODIFY_RET_F_Locked;
   }
   if (nStart < 0 || (nStart + nLength > GetTextBufLength())) {
@@ skipping 15 matching lines @@
   if (nLength > 0) {
     Inner_DeleteRange(nStart, nLength);
   }
   int32_t nTextLength = wsReplace.GetLength();
   if (nTextLength > 0) {
     Inner_Insert(nStart, wsReplace.c_str(), nTextLength);
   }
   m_ChangeInfo.wsInsert = CFX_WideString(wsReplace.c_str(), nTextLength);
   nStart += nTextLength;
   FX_WCHAR wChar = m_pTxtBuf->GetCharByIndex(nStart - 1);
-  FX_BOOL bBefore = TRUE;
+  bool bBefore = true;
   if (wChar != L'\n' && wChar != L'\r') {
     nStart--;
-    bBefore = FALSE;
+    bBefore = false;
   }
   SetCaretPos(nStart, bBefore);
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
   m_Param.pEventSink->On_TextChanged(this, m_ChangeInfo);
   return FDE_TXTEDT_MODIFY_RET_S_Normal;
 }
 
 void CFDE_TxtEdtEngine::SetLimit(int32_t nLimit) {
   m_nLimit = nLimit;
@@ skipping 34 matching lines @@
   lpTemp = m_SelRangePtrArr[nSize - 1];
   if (nStart >= lpTemp->nStart + lpTemp->nCount) {
     FDE_TXTEDTSELRANGE* lpSelRange = new FDE_TXTEDTSELRANGE;
     lpSelRange->nStart = nStart;
     lpSelRange->nCount = nCount;
     m_SelRangePtrArr.Add(lpSelRange);
     m_Param.pEventSink->On_SelChanged(this);
     return;
   }
   int32_t nEnd = nStart + nCount - 1;
-  FX_BOOL bBegin = FALSE;
+  bool bBegin = false;
   int32_t nRangeBgn = 0;
   int32_t nRangeCnt = 0;
   for (int32_t i = 0; i < nSize; i++) {
     lpTemp = m_SelRangePtrArr[i];
     int32_t nTempBgn = lpTemp->nStart;
     int32_t nTempEnd = nTempBgn + lpTemp->nCount - 1;
     if (bBegin) {
       if (nEnd < nTempBgn) {
         break;
       } else if (nStart >= nTempBgn && nStart <= nTempEnd) {
         nRangeCnt++;
         break;
       }
       nRangeCnt++;
     } else {
       if (nStart <= nTempEnd) {
         nRangeBgn = i;
         if (nEnd < nTempBgn) {
           break;
         }
         nRangeCnt = 1;
-        bBegin = TRUE;
+        bBegin = true;
       }
     }
   }
   if (nRangeCnt == 0) {
     FDE_TXTEDTSELRANGE* lpSelRange = new FDE_TXTEDTSELRANGE;
     lpSelRange->nStart = nStart;
     lpSelRange->nCount = nCount;
     m_SelRangePtrArr.InsertAt(nRangeBgn, lpSelRange);
   } else {
     lpTemp = m_SelRangePtrArr[nRangeBgn];
@@ skipping 20 matching lines @@
 
 void CFDE_TxtEdtEngine::ClearSelection() {
   int32_t nCount = m_SelRangePtrArr.GetSize();
   for (int i = 0; i < nCount; ++i)
     delete m_SelRangePtrArr[i];
   m_SelRangePtrArr.RemoveAll();
   if (nCount && m_Param.pEventSink)
     m_Param.pEventSink->On_SelChanged(this);
 }
 
-FX_BOOL CFDE_TxtEdtEngine::Redo(const IFDE_TxtEdtDoRecord* pDoRecord) {
+bool CFDE_TxtEdtEngine::Redo(const IFDE_TxtEdtDoRecord* pDoRecord) {
   if (IsLocked())
-    return FALSE;
+    return false;
   if (m_Param.dwMode & FDE_TEXTEDITMODE_NoRedoUndo)
-    return FALSE;
+    return false;
   return pDoRecord->Redo();
 }
 
-FX_BOOL CFDE_TxtEdtEngine::Undo(const IFDE_TxtEdtDoRecord* pDoRecord) {
+bool CFDE_TxtEdtEngine::Undo(const IFDE_TxtEdtDoRecord* pDoRecord) {
   if (IsLocked())
-    return FALSE;
+    return false;
   if (m_Param.dwMode & FDE_TEXTEDITMODE_NoRedoUndo)
-    return FALSE;
+    return false;
   return pDoRecord->Undo();
 }
 
 int32_t CFDE_TxtEdtEngine::StartLayout() {
   Lock();
   RemoveAllPages();
   m_nLayoutPos = 0;
   m_nLineCount = 0;
   return 0;
 }
@@ skipping 22 matching lines @@
     m_nCaret = nLength;
   }
   int32_t nIndex = m_nCaret;
   if (!m_bBefore) {
     nIndex--;
   }
   m_rtCaret.Set(0, 0, 1, m_Param.fFontSize);
   Unlock();
 }
 
-FX_BOOL CFDE_TxtEdtEngine::Optimize(IFX_Pause* pPause) {
+bool CFDE_TxtEdtEngine::Optimize(IFX_Pause* pPause) {
   return m_pTxtBuf->Optimize(pPause);
 }
 
 CFDE_TxtEdtBuf* CFDE_TxtEdtEngine::GetTextBuf() const {
   return m_pTxtBuf.get();
 }
 
 int32_t CFDE_TxtEdtEngine::GetTextBufLength() const {
   return m_pTxtBuf->GetTextLength() - 1;
 }
@@ skipping 108 matching lines @@
     m_ParagPtrArray[i]->IncrementStartIndex(nLength);
 
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   int32_t nReserveLineCount = pParag->GetLineCount();
   int32_t nReserveCharStart = pParag->GetStartIndex();
   int32_t nLeavePart = ParagPos.nCharIndex;
   int32_t nCutPart = pParag->GetTextLength() - ParagPos.nCharIndex;
   int32_t nTextStart = 0;
   FX_WCHAR wCurChar = L' ';
   const FX_WCHAR* lpPos = lpText;
-  FX_BOOL bFirst = TRUE;
+  bool bFirst = true;
   int32_t nParagIndex = ParagPos.nParagIndex;
   for (i = 0; i < nLength; i++, lpPos++) {
     wCurChar = *lpPos;
     if (wCurChar == m_wLineEnd) {
       if (bFirst) {
         pParag->SetTextLength(nLeavePart + (i - nTextStart + 1));
         pParag->SetLineCount(-1);
         nReserveCharStart += pParag->GetTextLength();
-        bFirst = FALSE;
+        bFirst = false;
       } else {
         pParag = new CFDE_TxtEdtParag(this);
         pParag->SetLineCount(-1);
         pParag->SetTextLength(i - nTextStart + 1);
         pParag->SetStartIndex(nReserveCharStart);
         m_ParagPtrArray.InsertAt(++nParagIndex, pParag);
         nReserveCharStart += pParag->GetTextLength();
       }
       nTextStart = i + 1;
     }
   }
   if (bFirst) {
     pParag->IncrementTextLength(nLength);
     pParag->SetLineCount(-1);
-    bFirst = FALSE;
+    bFirst = false;
   } else {
     pParag = new CFDE_TxtEdtParag(this);
     pParag->SetLineCount(-1);
     pParag->SetTextLength(nLength - nTextStart + nCutPart);
     pParag->SetStartIndex(nReserveCharStart);
     m_ParagPtrArray.InsertAt(++nParagIndex, pParag);
   }
   m_pTxtBuf->Insert(nStart, lpText, nLength);
   int32_t nTotalLineCount = 0;
   for (i = ParagPos.nParagIndex; i <= nParagIndex; i++) {
@@ skipping 10 matching lines @@
   if (nCount == -1) {
     nCount = m_pTxtBuf->GetTextLength() - nStart;
   }
   int32_t nEnd = nStart + nCount - 1;
   ASSERT(nStart >= 0 && nEnd < m_pTxtBuf->GetTextLength());
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
   FDE_TXTEDTPARAGPOS ParagPosBgn, ParagPosEnd;
   TextPos2ParagPos(nStart, ParagPosBgn);
   TextPos2ParagPos(nEnd, ParagPosEnd);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPosEnd.nParagIndex];
-  FX_BOOL bLastParag = FALSE;
+  bool bLastParag = false;
   if (ParagPosEnd.nCharIndex == pParag->GetTextLength() - 1) {
     if (ParagPosEnd.nParagIndex < m_ParagPtrArray.GetSize() - 1) {
       ParagPosEnd.nParagIndex++;
     } else {
-      bLastParag = TRUE;
+      bLastParag = true;
     }
   }
   int32_t nTotalLineCount = 0;
   int32_t nTotalCharCount = 0;
   int32_t i = 0;
   for (i = ParagPosBgn.nParagIndex; i <= ParagPosEnd.nParagIndex; i++) {
     CFDE_TxtEdtParag* pTextParag = m_ParagPtrArray[i];
     pTextParag->CalcLines();
     nTotalLineCount += pTextParag->GetLineCount();
     nTotalCharCount += pTextParag->GetTextLength();
@@ skipping 20 matching lines @@
   UpdatePages();
   int32_t nPageCount = CountPages();
   if (m_nCaretPage >= nPageCount) {
     m_nCaretPage = nPageCount - 1;
   }
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
 }
 
 void CFDE_TxtEdtEngine::DeleteRange_DoRecord(int32_t nStart,
                                              int32_t nCount,
-                                             FX_BOOL bSel) {
+                                             bool bSel) {
   ASSERT(nStart >= 0);
   if (nCount == -1) {
     nCount = GetTextLength() - nStart;
   }
   ASSERT((nStart + nCount) <= m_pTxtBuf->GetTextLength());
 
   if (!(m_Param.dwMode & FDE_TEXTEDITMODE_NoRedoUndo)) {
     CFX_WideString wsRange;
     m_pTxtBuf->GetRange(wsRange, nStart, nCount);
     m_Param.pEventSink->On_AddDoRecord(
         this, new CFDE_TxtEdtDoRecord_DeleteRange(this, nStart, m_nCaret,
                                                   wsRange, bSel));
   }
   m_ChangeInfo.nChangeType = FDE_TXTEDT_TEXTCHANGE_TYPE_Delete;
   GetText(m_ChangeInfo.wsDelete, nStart, nCount);
   Inner_DeleteRange(nStart, nCount);
 }
 
 void CFDE_TxtEdtEngine::ResetEngine() {
   RemoveAllPages();
   RemoveAllParags();
   ClearSelection();
   m_nCaret = 0;
-  m_pTxtBuf->Clear(FALSE);
+  m_pTxtBuf->Clear(false);
   m_nCaret = 0;
 }
 
 void CFDE_TxtEdtEngine::RebuildParagraphs() {
   RemoveAllParags();
   FX_WCHAR wChar = L' ';
   int32_t nParagStart = 0;
   int32_t nIndex = 0;
   std::unique_ptr<IFX_CharIter> pIter(new CFDE_TxtEdtBufIter(m_pTxtBuf.get()));
   pIter->SetAt(0);
@@ skipping 152 matching lines @@
   m_pTextBreak->SetFontSize(m_Param.fFontSize);
   m_pTextBreak->SetTabWidth(m_Param.fTabWidth, m_Param.bTabEquidistant);
   m_pTextBreak->SetDefaultChar(m_Param.wDefChar);
   m_pTextBreak->SetParagraphBreakChar(m_Param.wLineBreakChar);
   m_pTextBreak->SetCharRotation(m_Param.nCharRotation);
   m_pTextBreak->SetLineBreakTolerance(m_Param.fFontSize * 0.2f);
   m_pTextBreak->SetHorizontalScale(m_Param.nHorzScale);
   m_pTextBreak->SetCharSpace(m_Param.fCharSpace);
 }
 
-FX_BOOL CFDE_TxtEdtEngine::ReplaceParagEnd(FX_WCHAR*& lpText,
-                                           int32_t& nLength,
-                                           FX_BOOL bPreIsCR) {
+bool CFDE_TxtEdtEngine::ReplaceParagEnd(FX_WCHAR*& lpText,
+                                        int32_t& nLength,
+                                        bool bPreIsCR) {
   for (int32_t i = 0; i < nLength; i++) {
     FX_WCHAR wc = lpText[i];
     switch (wc) {
       case L'\r': {
         lpText[i] = m_wLineEnd;
-        bPreIsCR = TRUE;
+        bPreIsCR = true;
       } break;
       case L'\n': {
-        if (bPreIsCR == TRUE) {
+        if (bPreIsCR == true) {
           int32_t nNext = i + 1;
           if (nNext < nLength) {
             FXSYS_memmove(lpText + i, lpText + nNext,
                           (nLength - nNext) * sizeof(FX_WCHAR));
           }
           i--;
           nLength--;
-          bPreIsCR = FALSE;
+          bPreIsCR = false;
           if (m_bAutoLineEnd) {
             m_nFirstLineEnd = FDE_TXTEDIT_LINEEND_CRLF;
-            m_bAutoLineEnd = FALSE;
+            m_bAutoLineEnd = false;
           }
         } else {
           lpText[i] = m_wLineEnd;
           if (m_bAutoLineEnd) {
             m_nFirstLineEnd = FDE_TXTEDIT_LINEEND_LF;
-            m_bAutoLineEnd = FALSE;
+            m_bAutoLineEnd = false;
           }
         }
       } break;
       default: {
         if (bPreIsCR && m_bAutoLineEnd) {
           m_nFirstLineEnd = FDE_TXTEDIT_LINEEND_CR;
-          m_bAutoLineEnd = FALSE;
+          m_bAutoLineEnd = false;
         }
-        bPreIsCR = FALSE;
+        bPreIsCR = false;
       } break;
     }
   }
   return bPreIsCR;
 }
 
 void CFDE_TxtEdtEngine::RecoverParagEnd(CFX_WideString& wsText) {
   FX_WCHAR wc = (m_nFirstLineEnd == FDE_TXTEDIT_LINEEND_CR) ? L'\n' : L'\r';
   if (m_nFirstLineEnd == FDE_TXTEDIT_LINEEND_CRLF) {
     CFX_ArrayTemplate<int32_t> PosArr;
@@ skipping 99 matching lines @@
   if (nBgn == nEnd)
     nMid = nBgn;
 
   ASSERT(nIndex >= m_ParagPtrArray[nMid]->GetStartIndex() &&
          (nIndex < m_ParagPtrArray[nMid]->GetStartIndex() +
                        m_ParagPtrArray[nMid]->GetTextLength()));
   ParagPos.nParagIndex = nMid;
   ParagPos.nCharIndex = nIndex - m_ParagPtrArray[nMid]->GetStartIndex();
 }
 
-int32_t CFDE_TxtEdtEngine::MoveForward(FX_BOOL& bBefore) {
+int32_t CFDE_TxtEdtEngine::MoveForward(bool& bBefore) {
   if (m_nCaret == m_pTxtBuf->GetTextLength() - 1)
     return -1;
 
   int32_t nCaret = m_nCaret;
   if ((nCaret + 1 < m_pTxtBuf->GetTextLength()) &&
       (m_pTxtBuf->GetCharByIndex(nCaret) == L'\r') &&
       (m_pTxtBuf->GetCharByIndex(nCaret + 1) == L'\n')) {
     nCaret++;
   }
   nCaret++;
-  bBefore = TRUE;
+  bBefore = true;
   return nCaret;
 }
 
-int32_t CFDE_TxtEdtEngine::MoveBackward(FX_BOOL& bBefore) {
+int32_t CFDE_TxtEdtEngine::MoveBackward(bool& bBefore) {
   if (m_nCaret == 0)
-    return FALSE;
+    return false;
 
   int32_t nCaret = m_nCaret;
   if (nCaret > 2 && m_pTxtBuf->GetCharByIndex(nCaret - 1) == L'\n' &&
       m_pTxtBuf->GetCharByIndex(nCaret - 2) == L'\r') {
     nCaret--;
   }
   nCaret--;
-  bBefore = TRUE;
+  bBefore = true;
   return nCaret;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveUp(CFX_PointF& ptCaret) {
+bool CFDE_TxtEdtEngine::MoveUp(CFX_PointF& ptCaret) {
   IFDE_TxtEdtPage* pPage = GetPage(m_nCaretPage);
   const CFX_RectF& rtContent = pPage->GetContentsBox();
   if (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical) {
     ptCaret.x = m_rtCaret.left + m_rtCaret.width / 2 - m_Param.fLineSpace;
     ptCaret.y = m_fCaretPosReserve;
-    FX_BOOL bLineReserve =
+    bool bLineReserve =
         !!(m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_LineReserve);
     if (ptCaret.x < rtContent.left) {
       if (bLineReserve) {
         if (m_nCaretPage == CountPages() - 1) {
-          return FALSE;
+          return false;
         }
       } else {
         if (m_nCaretPage == 0) {
-          return FALSE;
+          return false;
         }
       }
       if (bLineReserve) {
         m_nCaretPage++;
       } else {
         m_nCaretPage--;
       }
       ptCaret.x -= rtContent.left;
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.x += pCurPage->GetContentsBox().right();
     }
   } else {
     ptCaret.x = m_fCaretPosReserve;
     ptCaret.y = m_rtCaret.top + m_rtCaret.height / 2 - m_Param.fLineSpace;
     if (ptCaret.y < rtContent.top) {
       if (m_nCaretPage == 0) {
-        return FALSE;
+        return false;
       }
       ptCaret.y -= rtContent.top;
       m_nCaretPage--;
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.y += pCurPage->GetContentsBox().bottom();
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveDown(CFX_PointF& ptCaret) {
+bool CFDE_TxtEdtEngine::MoveDown(CFX_PointF& ptCaret) {
   IFDE_TxtEdtPage* pPage = GetPage(m_nCaretPage);
   const CFX_RectF& rtContent = pPage->GetContentsBox();
   if (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical) {
     ptCaret.x = m_rtCaret.left + m_rtCaret.width / 2 + m_Param.fLineSpace;
     ptCaret.y = m_fCaretPosReserve;
     if (ptCaret.x >= rtContent.right()) {
-      FX_BOOL bLineReserve =
+      bool bLineReserve =
           !!(m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_LineReserve);
       if (bLineReserve) {
         if (m_nCaretPage == 0) {
-          return FALSE;
+          return false;
         }
       } else {
         if (m_nCaretPage == CountPages() - 1) {
-          return FALSE;
+          return false;
         }
       }
       if (bLineReserve) {
         m_nCaretPage--;
       } else {
         m_nCaretPage++;
       }
       ptCaret.x -= rtContent.right();
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.x += pCurPage->GetContentsBox().left;
     }
   } else {
     ptCaret.x = m_fCaretPosReserve;
     ptCaret.y = m_rtCaret.top + m_rtCaret.height / 2 + m_Param.fLineSpace;
     if (ptCaret.y >= rtContent.bottom()) {
       if (m_nCaretPage == CountPages() - 1) {
-        return FALSE;
+        return false;
       }
       ptCaret.y -= rtContent.bottom();
       m_nCaretPage++;
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.y += pCurPage->GetContentsBox().top;
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveLineStart() {
+bool CFDE_TxtEdtEngine::MoveLineStart() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   pParag->LoadParag();
   int32_t nLineCount = pParag->GetLineCount();
   int32_t i = 0;
   int32_t nStart = 0;
   int32_t nCount = 0;
   for (; i < nLineCount; i++) {
     pParag->GetLineRange(i, nStart, nCount);
     if (nIndex >= nStart && nIndex < nStart + nCount) {
       break;
     }
   }
-  UpdateCaretRect(nStart, TRUE);
+  UpdateCaretRect(nStart, true);
   pParag->UnloadParag();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveLineEnd() {
+bool CFDE_TxtEdtEngine::MoveLineEnd() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   pParag->LoadParag();
   int32_t nLineCount = pParag->GetLineCount();
   int32_t i = 0;
   int32_t nStart = 0;
   int32_t nCount = 0;
   for (; i < nLineCount; i++) {
     pParag->GetLineRange(i, nStart, nCount);
     if (nIndex >= nStart && nIndex < nStart + nCount) {
       break;
     }
   }
   nIndex = nStart + nCount - 1;
   ASSERT(nIndex <= GetTextBufLength());
   FX_WCHAR wChar = m_pTxtBuf->GetCharByIndex(nIndex);
-  FX_BOOL bBefore = FALSE;
+  bool bBefore = false;
   if (nIndex <= GetTextBufLength()) {
     if (wChar == L'\r') {
-      bBefore = TRUE;
+      bBefore = true;
     } else if (wChar == L'\n' && nIndex > nStart) {
-      bBefore = TRUE;
+      bBefore = true;
       nIndex--;
       wChar = m_pTxtBuf->GetCharByIndex(nIndex);
       if (wChar != L'\r') {
         nIndex++;
       }
     }
   }
   UpdateCaretRect(nIndex, bBefore);
   pParag->UnloadParag();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveParagStart() {
+bool CFDE_TxtEdtEngine::MoveParagStart() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
-  UpdateCaretRect(pParag->GetStartIndex(), TRUE);
-  return TRUE;
+  UpdateCaretRect(pParag->GetStartIndex(), true);
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveParagEnd() {
+bool CFDE_TxtEdtEngine::MoveParagEnd() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   nIndex = pParag->GetStartIndex() + pParag->GetTextLength() - 1;
   FX_WCHAR wChar = m_pTxtBuf->GetCharByIndex(nIndex);
   if (wChar == L'\n' && nIndex > 0) {
     nIndex--;
     wChar = m_pTxtBuf->GetCharByIndex(nIndex);
     if (wChar != L'\r') {
       nIndex++;
     }
   }
-  UpdateCaretRect(nIndex, TRUE);
-  return TRUE;
+  UpdateCaretRect(nIndex, true);
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveHome() {
-  UpdateCaretRect(0, TRUE);
-  return TRUE;
+bool CFDE_TxtEdtEngine::MoveHome() {
+  UpdateCaretRect(0, true);
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::MoveEnd() {
-  UpdateCaretRect(GetTextBufLength(), TRUE);
-  return TRUE;
+bool CFDE_TxtEdtEngine::MoveEnd() {
+  UpdateCaretRect(GetTextBufLength(), true);
+  return true;
 }
 
-FX_BOOL CFDE_TxtEdtEngine::IsFitArea(CFX_WideString& wsText) {
+bool CFDE_TxtEdtEngine::IsFitArea(CFX_WideString& wsText) {
   std::unique_ptr<CFDE_TextOut> pTextOut(new CFDE_TextOut);
   pTextOut->SetLineSpace(m_Param.fLineSpace);
   pTextOut->SetFont(m_Param.pFont);
   pTextOut->SetFontSize(m_Param.fFontSize);
   CFX_RectF rcText;
   FXSYS_memset(&rcText, 0, sizeof(rcText));
   uint32_t dwStyle = 0;
   if (!(m_Param.dwMode & FDE_TEXTEDITMODE_MultiLines))
     dwStyle |= FDE_TTOSTYLE_SingleLine;
 
   if (m_Param.dwMode & FDE_TEXTEDITMODE_AutoLineWrap) {
     dwStyle |= FDE_TTOSTYLE_LineWrap;
     rcText.width = m_Param.fPlateWidth;
   } else {
     rcText.width = 65535;
   }
   pTextOut->SetStyles(dwStyle);
   wsText += L"\n";
   pTextOut->CalcLogicSize(wsText.c_str(), wsText.GetLength(), rcText);
   wsText.Delete(wsText.GetLength() - 1);
   if ((m_Param.dwMode & FDE_TEXTEDITMODE_LimitArea_Horz) &&
       (rcText.width > m_Param.fPlateWidth)) {
-    return FALSE;
+    return false;
   }
   if ((m_Param.dwMode & FDE_TEXTEDITMODE_LimitArea_Vert) &&
       (rcText.height > m_Param.fLineSpace * m_Param.nLineCount)) {
-    return FALSE;
+    return false;
   }
-  return TRUE;
+  return true;
 }
 
-void CFDE_TxtEdtEngine::UpdateCaretRect(int32_t nIndex, FX_BOOL bBefore) {
+void CFDE_TxtEdtEngine::UpdateCaretRect(int32_t nIndex, bool bBefore) {
   MovePage2Char(nIndex);
   GetCaretRect(m_rtCaret, m_nCaretPage, nIndex, bBefore);
   m_nCaret = nIndex;
   m_bBefore = bBefore;
   if (!m_bBefore) {
     m_nCaret++;
-    m_bBefore = TRUE;
+    m_bBefore = true;
   }
   m_fCaretPosReserve = (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical)
                            ? m_rtCaret.top
                            : m_rtCaret.left;
   m_Param.pEventSink->On_CaretChanged(this, m_nCaretPage, 0);
 }
 
 void CFDE_TxtEdtEngine::GetCaretRect(CFX_RectF& rtCaret,
                                      int32_t nPageIndex,
                                      int32_t nCaret,
-                                     FX_BOOL bBefore) {
+                                     bool bBefore) {
   IFDE_TxtEdtPage* pPage = m_PagePtrArray[m_nCaretPage];
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
-  FX_BOOL bCombText = !!(m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_CombText);
+  bool bCombText = !!(m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_CombText);
   int32_t nIndexInpage = nCaret - pPage->GetCharStart();
   if (bBefore && bCombText && nIndexInpage > 0) {
     nIndexInpage--;
-    bBefore = FALSE;
+    bBefore = false;
   }
   int32_t nBIDILevel = pPage->GetCharRect(nIndexInpage, rtCaret, bCombText);
   if (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical) {
     if ((!FX_IsOdd(nBIDILevel) && !bBefore) ||
         (FX_IsOdd(nBIDILevel) && bBefore)) {
       rtCaret.Offset(0, rtCaret.height - 1.0f);
     }
     if (rtCaret.height == 0 && rtCaret.top > 1.0f)
       rtCaret.top -= 1.0f;
 
@@ skipping 11 matching lines @@
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
 }
 
 void CFDE_TxtEdtEngine::UpdateCaretIndex(const CFX_PointF& ptCaret) {
   IFDE_TxtEdtPage* pPage = m_PagePtrArray[m_nCaretPage];
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
   m_nCaret = pPage->GetCharIndex(ptCaret, m_bBefore);
   GetCaretRect(m_rtCaret, m_nCaretPage, m_nCaret, m_bBefore);
   if (!m_bBefore) {
     m_nCaret++;
-    m_bBefore = TRUE;
+    m_bBefore = true;
   }
   m_Param.pEventSink->On_CaretChanged(this, m_nCaretPage);
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
 }
 
-FX_BOOL CFDE_TxtEdtEngine::IsSelect() {
+bool CFDE_TxtEdtEngine::IsSelect() {
   return m_SelRangePtrArr.GetSize() > 0;
 }
 
 void CFDE_TxtEdtEngine::DeleteSelect() {
   int32_t nCountRange = CountSelRanges();
   if (nCountRange > 0) {
     int32_t nSelStart = 0;
     while (nCountRange > 0) {
       int32_t nSelCount = GetSelRange(--nCountRange, nSelStart);
       delete m_SelRangePtrArr[nCountRange];
       m_SelRangePtrArr.RemoveAt(nCountRange);
-      DeleteRange_DoRecord(nSelStart, nSelCount, TRUE);
+      DeleteRange_DoRecord(nSelStart, nSelCount, true);
     }
     ClearSelection();
     m_Param.pEventSink->On_TextChanged(this, m_ChangeInfo);
     m_Param.pEventSink->On_SelChanged(this);
-    SetCaretPos(nSelStart, TRUE);
+    SetCaretPos(nSelStart, true);
     return;
   }
 }