Remove FX_BOOL from fpdfsdk.

fpdfsdk/fxedit/fxet_edit.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 "fpdfsdk/fxedit/fxet_edit.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 146 matching lines @@
 }
 
 }  // namespace
 
 CFX_Edit_Iterator::CFX_Edit_Iterator(CFX_Edit* pEdit,
                                      CPDF_VariableText::Iterator* pVTIterator)
     : m_pEdit(pEdit), m_pVTIterator(pVTIterator) {}
 
 CFX_Edit_Iterator::~CFX_Edit_Iterator() {}
 
-FX_BOOL CFX_Edit_Iterator::NextWord() {
+bool CFX_Edit_Iterator::NextWord() {
   return m_pVTIterator->NextWord();
 }
 
-FX_BOOL CFX_Edit_Iterator::PrevWord() {
+bool CFX_Edit_Iterator::PrevWord() {
   return m_pVTIterator->PrevWord();
 }
 
-FX_BOOL CFX_Edit_Iterator::GetWord(CPVT_Word& word) const {
+bool CFX_Edit_Iterator::GetWord(CPVT_Word& word) const {
   ASSERT(m_pEdit);
 
   if (m_pVTIterator->GetWord(word)) {
     word.ptWord = m_pEdit->VTToEdit(word.ptWord);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit_Iterator::GetLine(CPVT_Line& line) const {
+bool CFX_Edit_Iterator::GetLine(CPVT_Line& line) const {
   ASSERT(m_pEdit);
 
   if (m_pVTIterator->GetLine(line)) {
     line.ptLine = m_pEdit->VTToEdit(line.ptLine);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit_Iterator::GetSection(CPVT_Section& section) const {
+bool CFX_Edit_Iterator::GetSection(CPVT_Section& section) const {
   ASSERT(m_pEdit);
 
   if (m_pVTIterator->GetSection(section)) {
     section.rcSection = m_pEdit->VTToEdit(section.rcSection);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 void CFX_Edit_Iterator::SetAt(int32_t nWordIndex) {
   m_pVTIterator->SetAt(nWordIndex);
 }
 
 void CFX_Edit_Iterator::SetAt(const CPVT_WordPlace& place) {
   m_pVTIterator->SetAt(place);
 }
 
@@ skipping 45 matching lines @@
 int32_t CFX_Edit_Provider::GetWordFontIndex(uint16_t word,
                                             int32_t charset,
                                             int32_t nFontIndex) {
   return m_pFontMap->GetWordFontIndex(word, charset, nFontIndex);
 }
 
 int32_t CFX_Edit_Provider::GetDefaultFontIndex() {
   return 0;
 }
 
-FX_BOOL CFX_Edit_Provider::IsLatinWord(uint16_t word) {
+bool CFX_Edit_Provider::IsLatinWord(uint16_t word) {
   return FX_EDIT_ISLATINWORD(word);
 }
 
 CFX_Edit_Refresh::CFX_Edit_Refresh() {}
 
 CFX_Edit_Refresh::~CFX_Edit_Refresh() {}
 
 void CFX_Edit_Refresh::BeginRefresh() {
   m_RefreshRects.Empty();
   m_OldLineRects = m_NewLineRects;
@@ skipping 26 matching lines @@
   return &m_RefreshRects;
 }
 
 void CFX_Edit_Refresh::EndRefresh() {
   m_RefreshRects.Empty();
 }
 
 CFX_Edit_Undo::CFX_Edit_Undo(int32_t nBufsize)
     : m_nCurUndoPos(0),
       m_nBufSize(nBufsize),
-      m_bModified(FALSE),
-      m_bVirgin(TRUE),
-      m_bWorking(FALSE) {}
+      m_bModified(false),
+      m_bVirgin(true),
+      m_bWorking(false) {}
 
 CFX_Edit_Undo::~CFX_Edit_Undo() {
   Reset();
 }
 
-FX_BOOL CFX_Edit_Undo::CanUndo() const {
+bool CFX_Edit_Undo::CanUndo() const {
   return m_nCurUndoPos > 0;
 }
 
 void CFX_Edit_Undo::Undo() {
-  m_bWorking = TRUE;
+  m_bWorking = true;
 
   if (m_nCurUndoPos > 0) {
     IFX_Edit_UndoItem* pItem = m_UndoItemStack.GetAt(m_nCurUndoPos - 1);
     pItem->Undo();
 
     m_nCurUndoPos--;
     m_bModified = (m_nCurUndoPos != 0);
   }
 
-  m_bWorking = FALSE;
+  m_bWorking = false;
 }
 
-FX_BOOL CFX_Edit_Undo::CanRedo() const {
+bool CFX_Edit_Undo::CanRedo() const {
   return m_nCurUndoPos < m_UndoItemStack.GetSize();
 }
 
 void CFX_Edit_Undo::Redo() {
-  m_bWorking = TRUE;
+  m_bWorking = true;
 
   int32_t nStackSize = m_UndoItemStack.GetSize();
 
   if (m_nCurUndoPos < nStackSize) {
     IFX_Edit_UndoItem* pItem = m_UndoItemStack.GetAt(m_nCurUndoPos);
     pItem->Redo();
 
     m_nCurUndoPos++;
     m_bModified = (m_nCurUndoPos != 0);
   }
 
-  m_bWorking = FALSE;
+  m_bWorking = false;
 }
 
 void CFX_Edit_Undo::AddItem(IFX_Edit_UndoItem* pItem) {
   ASSERT(!m_bWorking);
   ASSERT(pItem);
   ASSERT(m_nBufSize > 1);
 
   if (m_nCurUndoPos < m_UndoItemStack.GetSize())
     RemoveTails();
 
   if (m_UndoItemStack.GetSize() >= m_nBufSize) {
     RemoveHeads();
-    m_bVirgin = FALSE;
+    m_bVirgin = false;
   }
 
   m_UndoItemStack.Add(pItem);
   m_nCurUndoPos = m_UndoItemStack.GetSize();
 
   m_bModified = (m_nCurUndoPos != 0);
 }
 
-FX_BOOL CFX_Edit_Undo::IsModified() const {
-  return m_bVirgin ? m_bModified : TRUE;
+bool CFX_Edit_Undo::IsModified() const {
+  return m_bVirgin ? m_bModified : true;
 }
 
 void CFX_Edit_Undo::RemoveHeads() {
   ASSERT(m_UndoItemStack.GetSize() > 1);
 
   delete m_UndoItemStack.GetAt(0);
   m_UndoItemStack.RemoveAt(0);
 }
 
 void CFX_Edit_Undo::RemoveTails() {
   for (int32_t i = m_UndoItemStack.GetSize() - 1; i >= m_nCurUndoPos; i--) {
     delete m_UndoItemStack.GetAt(i);
     m_UndoItemStack.RemoveAt(i);
   }
 }
 
 void CFX_Edit_Undo::Reset() {
   for (int32_t i = 0, sz = m_UndoItemStack.GetSize(); i < sz; i++) {
     delete m_UndoItemStack.GetAt(i);
   }
   m_nCurUndoPos = 0;
   m_UndoItemStack.RemoveAll();
 }
 
-CFX_Edit_UndoItem::CFX_Edit_UndoItem() : m_bFirst(TRUE), m_bLast(TRUE) {}
+CFX_Edit_UndoItem::CFX_Edit_UndoItem() : m_bFirst(true), m_bLast(true) {}
 
 CFX_Edit_UndoItem::~CFX_Edit_UndoItem() {}
 
 CFX_WideString CFX_Edit_UndoItem::GetUndoTitle() {
   return L"";
 }
 
-void CFX_Edit_UndoItem::SetFirst(FX_BOOL bFirst) {
+void CFX_Edit_UndoItem::SetFirst(bool bFirst) {
   m_bFirst = bFirst;
 }
 
-void CFX_Edit_UndoItem::SetLast(FX_BOOL bLast) {
+void CFX_Edit_UndoItem::SetLast(bool bLast) {
   m_bLast = bLast;
 }
 
-FX_BOOL CFX_Edit_UndoItem::IsLast() {
+bool CFX_Edit_UndoItem::IsLast() {
   return m_bLast;
 }
 
 CFX_Edit_GroupUndoItem::CFX_Edit_GroupUndoItem(const CFX_WideString& sTitle)
     : m_sTitle(sTitle) {}
 
 CFX_Edit_GroupUndoItem::~CFX_Edit_GroupUndoItem() {
   for (int i = 0, sz = m_Items.GetSize(); i < sz; i++) {
     delete m_Items[i];
   }
 
   m_Items.RemoveAll();
 }
 
 void CFX_Edit_GroupUndoItem::AddUndoItem(CFX_Edit_UndoItem* pUndoItem) {
-  pUndoItem->SetFirst(FALSE);
-  pUndoItem->SetLast(FALSE);
+  pUndoItem->SetFirst(false);
+  pUndoItem->SetLast(false);
 
   m_Items.Add(pUndoItem);
 
   if (m_sTitle.IsEmpty())
     m_sTitle = pUndoItem->GetUndoTitle();
 }
 
 void CFX_Edit_GroupUndoItem::UpdateItems() {
   if (m_Items.GetSize() > 0) {
     CFX_Edit_UndoItem* pFirstItem = m_Items[0];
-    pFirstItem->SetFirst(TRUE);
+    pFirstItem->SetFirst(true);
 
     CFX_Edit_UndoItem* pLastItem = m_Items[m_Items.GetSize() - 1];
-    pLastItem->SetLast(TRUE);
+    pLastItem->SetLast(true);
   }
 }
 
 void CFX_Edit_GroupUndoItem::Undo() {
   for (int i = m_Items.GetSize() - 1; i >= 0; i--) {
     CFX_Edit_UndoItem* pUndoItem = m_Items[i];
     pUndoItem->Undo();
   }
 }
 
@@ skipping 23 matching lines @@
   if (pWordProps)
     m_WordProps = *pWordProps;
 }
 
 CFXEU_InsertWord::~CFXEU_InsertWord() {}
 
 void CFXEU_InsertWord::Redo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpOld);
-    m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, FALSE, TRUE);
+    m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, false, true);
   }
 }
 
 void CFXEU_InsertWord::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpNew);
-    m_pEdit->Backspace(FALSE, TRUE);
+    m_pEdit->Backspace(false, true);
   }
 }
 
 CFXEU_InsertReturn::CFXEU_InsertReturn(CFX_Edit* pEdit,
                                        const CPVT_WordPlace& wpOldPlace,
                                        const CPVT_WordPlace& wpNewPlace,
                                        const CPVT_SecProps* pSecProps,
                                        const CPVT_WordProps* pWordProps)
     : m_pEdit(pEdit),
       m_wpOld(wpOldPlace),
       m_wpNew(wpNewPlace),
       m_SecProps(),
       m_WordProps() {
   if (pSecProps)
     m_SecProps = *pSecProps;
   if (pWordProps)
     m_WordProps = *pWordProps;
 }
 
 CFXEU_InsertReturn::~CFXEU_InsertReturn() {}
 
 void CFXEU_InsertReturn::Redo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpOld);
-    m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, FALSE, TRUE);
+    m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, false, true);
   }
 }
 
 void CFXEU_InsertReturn::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpNew);
-    m_pEdit->Backspace(FALSE, TRUE);
+    m_pEdit->Backspace(false, true);
   }
 }
 
 CFXEU_Backspace::CFXEU_Backspace(CFX_Edit* pEdit,
                                  const CPVT_WordPlace& wpOldPlace,
                                  const CPVT_WordPlace& wpNewPlace,
                                  uint16_t word,
                                  int32_t charset,
                                  const CPVT_SecProps& SecProps,
                                  const CPVT_WordProps& WordProps)
     : m_pEdit(pEdit),
       m_wpOld(wpOldPlace),
       m_wpNew(wpNewPlace),
       m_Word(word),
       m_nCharset(charset),
       m_SecProps(SecProps),
       m_WordProps(WordProps) {}
 
 CFXEU_Backspace::~CFXEU_Backspace() {}
 
 void CFXEU_Backspace::Redo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpOld);
-    m_pEdit->Backspace(FALSE, TRUE);
+    m_pEdit->Backspace(false, true);
   }
 }
 
 void CFXEU_Backspace::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpNew);
     if (m_wpNew.SecCmp(m_wpOld) != 0) {
-      m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, FALSE, TRUE);
+      m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, false, true);
     } else {
-      m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, FALSE, TRUE);
+      m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, false, true);
     }
   }
 }
 
 CFXEU_Delete::CFXEU_Delete(CFX_Edit* pEdit,
                            const CPVT_WordPlace& wpOldPlace,
                            const CPVT_WordPlace& wpNewPlace,
                            uint16_t word,
                            int32_t charset,
                            const CPVT_SecProps& SecProps,
                            const CPVT_WordProps& WordProps,
-                           FX_BOOL bSecEnd)
+                           bool bSecEnd)
     : m_pEdit(pEdit),
       m_wpOld(wpOldPlace),
       m_wpNew(wpNewPlace),
       m_Word(word),
       m_nCharset(charset),
       m_SecProps(SecProps),
       m_WordProps(WordProps),
       m_bSecEnd(bSecEnd) {}
 
 CFXEU_Delete::~CFXEU_Delete() {}
 
 void CFXEU_Delete::Redo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpOld);
-    m_pEdit->Delete(FALSE, TRUE);
+    m_pEdit->Delete(false, true);
   }
 }
 
 void CFXEU_Delete::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpNew);
     if (m_bSecEnd) {
-      m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, FALSE, TRUE);
+      m_pEdit->InsertReturn(&m_SecProps, &m_WordProps, false, true);
     } else {
-      m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, FALSE, TRUE);
+      m_pEdit->InsertWord(m_Word, m_nCharset, &m_WordProps, false, true);
     }
   }
 }
 
 CFXEU_Clear::CFXEU_Clear(CFX_Edit* pEdit,
                          const CPVT_WordRange& wrSel,
                          const CFX_WideString& swText)
     : m_pEdit(pEdit), m_wrSel(wrSel), m_swText(swText) {}
 
 CFXEU_Clear::~CFXEU_Clear() {}
 
 void CFXEU_Clear::Redo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetSel(m_wrSel.BeginPos, m_wrSel.EndPos);
-    m_pEdit->Clear(FALSE, TRUE);
+    m_pEdit->Clear(false, true);
   }
 }
 
 void CFXEU_Clear::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wrSel.BeginPos);
-    m_pEdit->InsertText(m_swText, FXFONT_DEFAULT_CHARSET, FALSE, TRUE);
+    m_pEdit->InsertText(m_swText, FXFONT_DEFAULT_CHARSET, false, true);
     m_pEdit->SetSel(m_wrSel.BeginPos, m_wrSel.EndPos);
   }
 }
 
 CFXEU_InsertText::CFXEU_InsertText(CFX_Edit* pEdit,
                                    const CPVT_WordPlace& wpOldPlace,
                                    const CPVT_WordPlace& wpNewPlace,
                                    const CFX_WideString& swText,
                                    int32_t charset)
     : m_pEdit(pEdit),
       m_wpOld(wpOldPlace),
       m_wpNew(wpNewPlace),
       m_swText(swText),
       m_nCharset(charset) {}
 
 CFXEU_InsertText::~CFXEU_InsertText() {}
 
 void CFXEU_InsertText::Redo() {
   if (m_pEdit && IsLast()) {
     m_pEdit->SelectNone();
     m_pEdit->SetCaret(m_wpOld);
-    m_pEdit->InsertText(m_swText, m_nCharset, FALSE, TRUE);
+    m_pEdit->InsertText(m_swText, m_nCharset, false, true);
   }
 }
 
 void CFXEU_InsertText::Undo() {
   if (m_pEdit) {
     m_pEdit->SelectNone();
     m_pEdit->SetSel(m_wpOld, m_wpNew);
-    m_pEdit->Clear(FALSE, TRUE);
+    m_pEdit->Clear(false, true);
   }
 }
 
 // static
 CFX_ByteString CFX_Edit::GetEditAppearanceStream(CFX_Edit* pEdit,
                                                  const CFX_FloatPoint& ptOffset,
                                                  const CPVT_WordRange* pRange,
-                                                 FX_BOOL bContinuous,
+                                                 bool bContinuous,
                                                  uint16_t SubWord) {
   CFX_Edit_Iterator* pIterator = pEdit->GetIterator();
   if (pRange)
     pIterator->SetAt(pRange->BeginPos);
   else
     pIterator->SetAt(0);
 
   CFX_ByteTextBuf sEditStream;
   CFX_ByteTextBuf sWords;
   int32_t nCurFontIndex = -1;
@@ skipping 139 matching lines @@
   const bool bContinuous =
       pEdit->GetCharArray() == 0 && pEdit->GetCharSpace() <= 0.0f;
   uint16_t SubWord = pEdit->GetPasswordChar();
   FX_FLOAT fFontSize = pEdit->GetFontSize();
   CPVT_WordRange wrSelect = pEdit->GetSelectWordRange();
   int32_t nHorzScale = pEdit->GetHorzScale();
 
   FX_COLORREF crCurFill = crTextFill;
   FX_COLORREF crOldFill = crCurFill;
 
-  FX_BOOL bSelect = FALSE;
+  bool bSelect = false;
   const FX_COLORREF crWhite = ArgbEncode(255, 255, 255, 255);
   const FX_COLORREF crSelBK = ArgbEncode(255, 0, 51, 113);
 
   CFX_ByteTextBuf sTextBuf;
   int32_t nFontIndex = -1;
   CFX_FloatPoint ptBT;
   pDevice->SaveState();
   if (!rcClip.IsEmpty()) {
     CFX_FloatRect rcTemp = rcClip;
     pUser2Device->TransformRect(rcTemp);
@@ skipping 151 matching lines @@
   }
 }
 
 CFX_Edit::CFX_Edit()
     : m_pVT(new CPDF_VariableText),
       m_pNotify(nullptr),
       m_pOprNotify(nullptr),
       m_wpCaret(-1, -1, -1),
       m_wpOldCaret(-1, -1, -1),
       m_SelState(),
-      m_bEnableScroll(FALSE),
+      m_bEnableScroll(false),
       m_Undo(kEditUndoMaxItems),
       m_nAlignment(0),
-      m_bNotifyFlag(FALSE),
-      m_bEnableOverflow(FALSE),
-      m_bEnableRefresh(TRUE),
+      m_bNotifyFlag(false),
+      m_bEnableOverflow(false),
+      m_bEnableRefresh(true),
       m_rcOldContent(0.0f, 0.0f, 0.0f, 0.0f),
-      m_bEnableUndo(TRUE),
-      m_bOprNotify(FALSE),
+      m_bEnableUndo(true),
+      m_bOprNotify(false),
       m_pGroupUndoItem(nullptr) {}
 
 CFX_Edit::~CFX_Edit() {
   ASSERT(!m_pGroupUndoItem);
 }
 
 void CFX_Edit::Initialize() {
   m_pVT->Initialize();
   SetCaret(m_pVT->GetBeginWordPlace());
   SetCaretOrigin();
@@ skipping 23 matching lines @@
 IPVT_FontMap* CFX_Edit::GetFontMap() {
   return m_pVTProvider ? m_pVTProvider->GetFontMap() : nullptr;
 }
 
 void CFX_Edit::SetPlateRect(const CFX_FloatRect& rect) {
   m_pVT->SetPlateRect(rect);
   m_ptScrollPos = CFX_FloatPoint(rect.left, rect.top);
   Paint();
 }
 
-void CFX_Edit::SetAlignmentH(int32_t nFormat, FX_BOOL bPaint) {
+void CFX_Edit::SetAlignmentH(int32_t nFormat, bool bPaint) {
   m_pVT->SetAlignment(nFormat);
   if (bPaint)
     Paint();
 }
 
-void CFX_Edit::SetAlignmentV(int32_t nFormat, FX_BOOL bPaint) {
+void CFX_Edit::SetAlignmentV(int32_t nFormat, bool bPaint) {
   m_nAlignment = nFormat;
   if (bPaint)
     Paint();
 }
 
-void CFX_Edit::SetPasswordChar(uint16_t wSubWord, FX_BOOL bPaint) {
+void CFX_Edit::SetPasswordChar(uint16_t wSubWord, bool bPaint) {
   m_pVT->SetPasswordChar(wSubWord);
   if (bPaint)
     Paint();
 }
 
 void CFX_Edit::SetLimitChar(int32_t nLimitChar) {
   m_pVT->SetLimitChar(nLimitChar);
   Paint();
 }
 
 void CFX_Edit::SetCharArray(int32_t nCharArray) {
   m_pVT->SetCharArray(nCharArray);
   Paint();
 }
 
 void CFX_Edit::SetCharSpace(FX_FLOAT fCharSpace) {
   m_pVT->SetCharSpace(fCharSpace);
   Paint();
 }
 
-void CFX_Edit::SetMultiLine(FX_BOOL bMultiLine, FX_BOOL bPaint) {
+void CFX_Edit::SetMultiLine(bool bMultiLine, bool bPaint) {
   m_pVT->SetMultiLine(bMultiLine);
   if (bPaint)
     Paint();
 }
 
-void CFX_Edit::SetAutoReturn(FX_BOOL bAuto, FX_BOOL bPaint) {
+void CFX_Edit::SetAutoReturn(bool bAuto, bool bPaint) {
   m_pVT->SetAutoReturn(bAuto);
   if (bPaint)
     Paint();
 }
 
-void CFX_Edit::SetAutoFontSize(FX_BOOL bAuto, FX_BOOL bPaint) {
+void CFX_Edit::SetAutoFontSize(bool bAuto, bool bPaint) {
   m_pVT->SetAutoFontSize(bAuto);
   if (bPaint)
     Paint();
 }
 
 void CFX_Edit::SetFontSize(FX_FLOAT fFontSize) {
   m_pVT->SetFontSize(fFontSize);
   Paint();
 }
 
-void CFX_Edit::SetAutoScroll(FX_BOOL bAuto, FX_BOOL bPaint) {
+void CFX_Edit::SetAutoScroll(bool bAuto, bool bPaint) {
   m_bEnableScroll = bAuto;
   if (bPaint)
     Paint();
 }
 
-void CFX_Edit::SetTextOverflow(FX_BOOL bAllowed, FX_BOOL bPaint) {
+void CFX_Edit::SetTextOverflow(bool bAllowed, bool bPaint) {
   m_bEnableOverflow = bAllowed;
   if (bPaint)
     Paint();
 }
 
 void CFX_Edit::SetSel(int32_t nStartChar, int32_t nEndChar) {
   if (m_pVT->IsValid()) {
     if (nStartChar == 0 && nEndChar < 0) {
       SelectAll();
     } else if (nStartChar < 0) {
@@ skipping 139 matching lines @@
 CPVT_WordRange CFX_Edit::GetSelectWordRange() const {
   return m_SelState.ConvertToWordRange();
 }
 
 void CFX_Edit::SetText(const CFX_WideString& sText) {
   Empty();
   DoInsertText(CPVT_WordPlace(0, 0, -1), sText, FXFONT_DEFAULT_CHARSET);
   Paint();
 }
 
-FX_BOOL CFX_Edit::InsertWord(uint16_t word, int32_t charset) {
-  return InsertWord(word, charset, nullptr, TRUE, TRUE);
+bool CFX_Edit::InsertWord(uint16_t word, int32_t charset) {
+  return InsertWord(word, charset, nullptr, true, true);
 }
 
-FX_BOOL CFX_Edit::InsertReturn() {
-  return InsertReturn(nullptr, nullptr, TRUE, TRUE);
+bool CFX_Edit::InsertReturn() {
+  return InsertReturn(nullptr, nullptr, true, true);
 }
 
-FX_BOOL CFX_Edit::Backspace() {
-  return Backspace(TRUE, TRUE);
+bool CFX_Edit::Backspace() {
+  return Backspace(true, true);
 }
 
-FX_BOOL CFX_Edit::Delete() {
-  return Delete(TRUE, TRUE);
+bool CFX_Edit::Delete() {
+  return Delete(true, true);
 }
 
-FX_BOOL CFX_Edit::Clear() {
-  return Clear(TRUE, TRUE);
+bool CFX_Edit::Clear() {
+  return Clear(true, true);
 }
 
-FX_BOOL CFX_Edit::InsertText(const CFX_WideString& sText, int32_t charset) {
-  return InsertText(sText, charset, TRUE, TRUE);
+bool CFX_Edit::InsertText(const CFX_WideString& sText, int32_t charset) {
+  return InsertText(sText, charset, true, true);
 }
 
 FX_FLOAT CFX_Edit::GetFontSize() const {
   return m_pVT->GetFontSize();
 }
 
 uint16_t CFX_Edit::GetPasswordChar() const {
   return m_pVT->GetPasswordChar();
 }
 
@@ skipping 75 matching lines @@
     SetContentChanged();
   }
 }
 
 void CFX_Edit::SetContentChanged() {
   if (m_pNotify) {
     CFX_FloatRect rcContent = m_pVT->GetContentRect();
     if (rcContent.Width() != m_rcOldContent.Width() ||
         rcContent.Height() != m_rcOldContent.Height()) {
       if (!m_bNotifyFlag) {
-        m_bNotifyFlag = TRUE;
+        m_bNotifyFlag = true;
         m_pNotify->IOnContentChange(rcContent);
-        m_bNotifyFlag = FALSE;
+        m_bNotifyFlag = false;
       }
       m_rcOldContent = rcContent;
     }
   }
 }
 
 void CFX_Edit::SelectAll() {
   if (m_pVT->IsValid()) {
     m_SelState = CFX_Edit_Select(GetWholeWordRange());
     SetCaret(m_SelState.EndPos);
 
     ScrollToCaret();
     Refresh();
     SetCaretInfo();
   }
 }
 
 void CFX_Edit::SelectNone() {
   if (m_pVT->IsValid()) {
     if (m_SelState.IsExist()) {
       m_SelState.Default();
       Refresh();
     }
   }
 }
 
-FX_BOOL CFX_Edit::IsSelected() const {
+bool CFX_Edit::IsSelected() const {
   return m_SelState.IsExist();
 }
 
 CFX_FloatPoint CFX_Edit::VTToEdit(const CFX_FloatPoint& point) const {
   CFX_FloatRect rcContent = m_pVT->GetContentRect();
   CFX_FloatRect rcPlate = m_pVT->GetPlateRect();
 
   FX_FLOAT fPadding = 0.0f;
 
   switch (m_nAlignment) {
@@ skipping 42 matching lines @@
   return CFX_FloatRect(ptLeftBottom.x, ptLeftBottom.y, ptRightTop.x,
                        ptRightTop.y);
 }
 
 void CFX_Edit::SetScrollInfo() {
   if (m_pNotify) {
     CFX_FloatRect rcPlate = m_pVT->GetPlateRect();
     CFX_FloatRect rcContent = m_pVT->GetContentRect();
 
     if (!m_bNotifyFlag) {
-      m_bNotifyFlag = TRUE;
+      m_bNotifyFlag = true;
       m_pNotify->IOnSetScrollInfoY(rcPlate.bottom, rcPlate.top,
                                    rcContent.bottom, rcContent.top,
                                    rcPlate.Height() / 3, rcPlate.Height());
-      m_bNotifyFlag = FALSE;
+      m_bNotifyFlag = false;
     }
   }
 }
 
 void CFX_Edit::SetScrollPosX(FX_FLOAT fx) {
   if (!m_bEnableScroll)
     return;
 
   if (m_pVT->IsValid()) {
     if (!IsFloatEqual(m_ptScrollPos.x, fx)) {
       m_ptScrollPos.x = fx;
       Refresh();
     }
   }
 }
 
 void CFX_Edit::SetScrollPosY(FX_FLOAT fy) {
   if (!m_bEnableScroll)
     return;
 
   if (m_pVT->IsValid()) {
     if (!IsFloatEqual(m_ptScrollPos.y, fy)) {
       m_ptScrollPos.y = fy;
       Refresh();
 
       if (m_pNotify) {
         if (!m_bNotifyFlag) {
-          m_bNotifyFlag = TRUE;
+          m_bNotifyFlag = true;
           m_pNotify->IOnSetScrollPosY(fy);
-          m_bNotifyFlag = FALSE;
+          m_bNotifyFlag = false;
         }
       }
     }
   }
 }
 
 void CFX_Edit::SetScrollPos(const CFX_FloatPoint& point) {
   SetScrollPosX(point.x);
   SetScrollPosY(point.y);
   SetScrollLimit();
@@ skipping 87 matching lines @@
 void CFX_Edit::Refresh() {
   if (m_bEnableRefresh && m_pVT->IsValid()) {
     m_Refresh.BeginRefresh();
     RefreshPushLineRects(GetVisibleWordRange());
 
     m_Refresh.NoAnalyse();
     m_ptRefreshScrollPos = m_ptScrollPos;
 
     if (m_pNotify) {
       if (!m_bNotifyFlag) {
-        m_bNotifyFlag = TRUE;
+        m_bNotifyFlag = true;
         if (const CFX_Edit_RectArray* pRects = m_Refresh.GetRefreshRects()) {
           for (int32_t i = 0, sz = pRects->GetSize(); i < sz; i++)
             m_pNotify->IOnInvalidateRect(pRects->GetAt(i));
         }
-        m_bNotifyFlag = FALSE;
+        m_bNotifyFlag = false;
       }
     }
 
     m_Refresh.EndRefresh();
   }
 }
 
 void CFX_Edit::RefreshPushLineRects(const CPVT_WordRange& wr) {
   if (!m_pVT->IsValid())
     return;
@@ skipping 44 matching lines @@
 
     if (place.LineCmp(wrTemp.BeginPos) == 0 ||
         place.LineCmp(wrTemp.EndPos) == 0) {
       CFX_FloatRect rcWord(wordinfo.ptWord.x,
                            lineinfo.ptLine.y + lineinfo.fLineDescent,
                            wordinfo.ptWord.x + wordinfo.fWidth,
                            lineinfo.ptLine.y + lineinfo.fLineAscent);
 
       if (m_pNotify) {
         if (!m_bNotifyFlag) {
-          m_bNotifyFlag = TRUE;
+          m_bNotifyFlag = true;
           CFX_FloatRect rcRefresh = VTToEdit(rcWord);
           m_pNotify->IOnInvalidateRect(&rcRefresh);
-          m_bNotifyFlag = FALSE;
+          m_bNotifyFlag = false;
         }
       }
     } else {
       CFX_FloatRect rcLine(lineinfo.ptLine.x,
                            lineinfo.ptLine.y + lineinfo.fLineDescent,
                            lineinfo.ptLine.x + lineinfo.fLineWidth,
                            lineinfo.ptLine.y + lineinfo.fLineAscent);
 
       if (m_pNotify) {
         if (!m_bNotifyFlag) {
-          m_bNotifyFlag = TRUE;
+          m_bNotifyFlag = true;
           CFX_FloatRect rcRefresh = VTToEdit(rcLine);
           m_pNotify->IOnInvalidateRect(&rcRefresh);
-          m_bNotifyFlag = FALSE;
+          m_bNotifyFlag = false;
         }
       }
 
       pIterator->NextLine();
     }
   }
 }
 
 void CFX_Edit::SetCaret(const CPVT_WordPlace& place) {
   m_wpOldCaret = m_wpCaret;
@@ skipping 15 matching lines @@
         ptHead.y = word.ptWord.y + word.fAscent;
         ptFoot.x = word.ptWord.x + word.fWidth;
         ptFoot.y = word.ptWord.y + word.fDescent;
       } else if (pIterator->GetLine(line)) {
         ptHead.x = line.ptLine.x;
         ptHead.y = line.ptLine.y + line.fLineAscent;
         ptFoot.x = line.ptLine.x;
         ptFoot.y = line.ptLine.y + line.fLineDescent;
       }
 
-      m_bNotifyFlag = TRUE;
+      m_bNotifyFlag = true;
       m_pNotify->IOnSetCaret(!m_SelState.IsExist(), VTToEdit(ptHead),
                              VTToEdit(ptFoot), m_wpCaret);
-      m_bNotifyFlag = FALSE;
+      m_bNotifyFlag = false;
     }
   }
 }
 
 void CFX_Edit::SetCaret(int32_t nPos) {
   if (m_pVT->IsValid()) {
     SelectNone();
     SetCaret(m_pVT->WordIndexToWordPlace(nPos));
     m_SelState.Set(m_wpCaret, m_wpCaret);
 
     ScrollToCaret();
     SetCaretOrigin();
     SetCaretInfo();
   }
 }
 
 void CFX_Edit::OnMouseDown(const CFX_FloatPoint& point,
-                           FX_BOOL bShift,
-                           FX_BOOL bCtrl) {
+                           bool bShift,
+                           bool bCtrl) {
   if (m_pVT->IsValid()) {
     SelectNone();
     SetCaret(m_pVT->SearchWordPlace(EditToVT(point)));
     m_SelState.Set(m_wpCaret, m_wpCaret);
 
     ScrollToCaret();
     SetCaretOrigin();
     SetCaretInfo();
   }
 }
 
 void CFX_Edit::OnMouseMove(const CFX_FloatPoint& point,
-                           FX_BOOL bShift,
-                           FX_BOOL bCtrl) {
+                           bool bShift,
+                           bool bCtrl) {
   if (m_pVT->IsValid()) {
     SetCaret(m_pVT->SearchWordPlace(EditToVT(point)));
 
     if (m_wpCaret != m_wpOldCaret) {
       m_SelState.SetEndPos(m_wpCaret);
 
       ScrollToCaret();
       Refresh();
       SetCaretOrigin();
       SetCaretInfo();
     }
   }
 }
 
-void CFX_Edit::OnVK_UP(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_UP(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     SetCaret(m_pVT->GetUpWordPlace(m_wpCaret, m_ptCaret));
 
     if (bShift) {
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
       else
         m_SelState.Set(m_wpOldCaret, m_wpCaret);
 
       if (m_wpOldCaret != m_wpCaret) {
         ScrollToCaret();
         Refresh();
         SetCaretInfo();
       }
     } else {
       SelectNone();
 
       ScrollToCaret();
       SetCaretInfo();
     }
   }
 }
 
-void CFX_Edit::OnVK_DOWN(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_DOWN(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     SetCaret(m_pVT->GetDownWordPlace(m_wpCaret, m_ptCaret));
 
     if (bShift) {
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
       else
         m_SelState.Set(m_wpOldCaret, m_wpCaret);
 
       if (m_wpOldCaret != m_wpCaret) {
         ScrollToCaret();
         Refresh();
         SetCaretInfo();
       }
     } else {
       SelectNone();
 
       ScrollToCaret();
       SetCaretInfo();
     }
   }
 }
 
-void CFX_Edit::OnVK_LEFT(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_LEFT(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     if (bShift) {
       if (m_wpCaret == m_pVT->GetLineBeginPlace(m_wpCaret) &&
           m_wpCaret != m_pVT->GetSectionBeginPlace(m_wpCaret))
         SetCaret(m_pVT->GetPrevWordPlace(m_wpCaret));
 
       SetCaret(m_pVT->GetPrevWordPlace(m_wpCaret));
 
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
@@ skipping 23 matching lines @@
         SetCaret(m_pVT->GetPrevWordPlace(m_wpCaret));
 
         ScrollToCaret();
         SetCaretOrigin();
         SetCaretInfo();
       }
     }
   }
 }
 
-void CFX_Edit::OnVK_RIGHT(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_RIGHT(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     if (bShift) {
       SetCaret(m_pVT->GetNextWordPlace(m_wpCaret));
 
       if (m_wpCaret == m_pVT->GetLineEndPlace(m_wpCaret) &&
           m_wpCaret != m_pVT->GetSectionEndPlace(m_wpCaret))
         SetCaret(m_pVT->GetNextWordPlace(m_wpCaret));
 
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
@@ skipping 23 matching lines @@
           SetCaret(m_pVT->GetNextWordPlace(m_wpCaret));
 
         ScrollToCaret();
         SetCaretOrigin();
         SetCaretInfo();
       }
     }
   }
 }
 
-void CFX_Edit::OnVK_HOME(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_HOME(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     if (bShift) {
       if (bCtrl)
         SetCaret(m_pVT->GetBeginWordPlace());
       else
         SetCaret(m_pVT->GetLineBeginPlace(m_wpCaret));
 
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
       else
@@ skipping 19 matching lines @@
           SetCaret(m_pVT->GetLineBeginPlace(m_wpCaret));
 
         ScrollToCaret();
         SetCaretOrigin();
         SetCaretInfo();
       }
     }
   }
 }
 
-void CFX_Edit::OnVK_END(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_Edit::OnVK_END(bool bShift, bool bCtrl) {
   if (m_pVT->IsValid()) {
     if (bShift) {
       if (bCtrl)
         SetCaret(m_pVT->GetEndWordPlace());
       else
         SetCaret(m_pVT->GetLineEndPlace(m_wpCaret));
 
       if (m_SelState.IsExist())
         m_SelState.SetEndPos(m_wpCaret);
       else
@@ skipping 19 matching lines @@
           SetCaret(m_pVT->GetLineEndPlace(m_wpCaret));
 
         ScrollToCaret();
         SetCaretOrigin();
         SetCaretInfo();
       }
     }
   }
 }
 
-FX_BOOL CFX_Edit::InsertWord(uint16_t word,
-                             int32_t charset,
-                             const CPVT_WordProps* pWordProps,
-                             FX_BOOL bAddUndo,
-                             FX_BOOL bPaint) {
+bool CFX_Edit::InsertWord(uint16_t word,
+                          int32_t charset,
+                          const CPVT_WordProps* pWordProps,
+                          bool bAddUndo,
+                          bool bPaint) {
   if (IsTextOverflow())
-    return FALSE;
+    return false;
 
   if (m_pVT->IsValid()) {
     m_pVT->UpdateWordPlace(m_wpCaret);
 
     SetCaret(m_pVT->InsertWord(
         m_wpCaret, word, GetCharSetFromUnicode(word, charset), pWordProps));
     m_SelState.Set(m_wpCaret, m_wpCaret);
 
     if (m_wpCaret != m_wpOldCaret) {
       if (bAddUndo && m_bEnableUndo) {
         AddEditUndoItem(new CFXEU_InsertWord(this, m_wpOldCaret, m_wpCaret,
                                              word, charset, pWordProps));
       }
 
       if (bPaint)
         PaintInsertText(m_wpOldCaret, m_wpCaret);
 
       if (m_bOprNotify && m_pOprNotify)
         m_pOprNotify->OnInsertWord(m_wpCaret, m_wpOldCaret);
 
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::InsertReturn(const CPVT_SecProps* pSecProps,
-                               const CPVT_WordProps* pWordProps,
-                               FX_BOOL bAddUndo,
-                               FX_BOOL bPaint) {
+bool CFX_Edit::InsertReturn(const CPVT_SecProps* pSecProps,
+                            const CPVT_WordProps* pWordProps,
+                            bool bAddUndo,
+                            bool bPaint) {
   if (IsTextOverflow())
-    return FALSE;
+    return false;
 
   if (m_pVT->IsValid()) {
     m_pVT->UpdateWordPlace(m_wpCaret);
     SetCaret(m_pVT->InsertSection(m_wpCaret, pSecProps, pWordProps));
     m_SelState.Set(m_wpCaret, m_wpCaret);
 
     if (m_wpCaret != m_wpOldCaret) {
       if (bAddUndo && m_bEnableUndo) {
         AddEditUndoItem(new CFXEU_InsertReturn(this, m_wpOldCaret, m_wpCaret,
                                                pSecProps, pWordProps));
       }
 
       if (bPaint) {
         RearrangePart(CPVT_WordRange(m_wpOldCaret, m_wpCaret));
         ScrollToCaret();
         Refresh();
         SetCaretOrigin();
         SetCaretInfo();
       }
 
       if (m_bOprNotify && m_pOprNotify)
         m_pOprNotify->OnInsertReturn(m_wpCaret, m_wpOldCaret);
 
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::Backspace(FX_BOOL bAddUndo, FX_BOOL bPaint) {
+bool CFX_Edit::Backspace(bool bAddUndo, bool bPaint) {
   if (m_pVT->IsValid()) {
     if (m_wpCaret == m_pVT->GetBeginWordPlace())
-      return FALSE;
+      return false;
 
     CPVT_Section section;
     CPVT_Word word;
 
     if (bAddUndo) {
       CPDF_VariableText::Iterator* pIterator = m_pVT->GetIterator();
       pIterator->SetAt(m_wpCaret);
       pIterator->GetSection(section);
       pIterator->GetWord(word);
     }
@@ skipping 18 matching lines @@
         RearrangePart(CPVT_WordRange(m_wpCaret, m_wpOldCaret));
         ScrollToCaret();
         Refresh();
         SetCaretOrigin();
         SetCaretInfo();
       }
 
       if (m_bOprNotify && m_pOprNotify)
         m_pOprNotify->OnBackSpace(m_wpCaret, m_wpOldCaret);
 
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::Delete(FX_BOOL bAddUndo, FX_BOOL bPaint) {
+bool CFX_Edit::Delete(bool bAddUndo, bool bPaint) {
   if (m_pVT->IsValid()) {
     if (m_wpCaret == m_pVT->GetEndWordPlace())
-      return FALSE;
+      return false;
 
     CPVT_Section section;
     CPVT_Word word;
 
     if (bAddUndo) {
       CPDF_VariableText::Iterator* pIterator = m_pVT->GetIterator();
       pIterator->SetAt(m_pVT->GetNextWordPlace(m_wpCaret));
       pIterator->GetSection(section);
       pIterator->GetWord(word);
     }
 
     m_pVT->UpdateWordPlace(m_wpCaret);
-    FX_BOOL bSecEnd = (m_wpCaret == m_pVT->GetSectionEndPlace(m_wpCaret));
+    bool bSecEnd = (m_wpCaret == m_pVT->GetSectionEndPlace(m_wpCaret));
 
     SetCaret(m_pVT->DeleteWord(m_wpCaret));
     m_SelState.Set(m_wpCaret, m_wpCaret);
 
     if (bAddUndo && m_bEnableUndo) {
       if (bSecEnd)
         AddEditUndoItem(new CFXEU_Delete(
             this, m_wpOldCaret, m_wpCaret, word.Word, word.nCharset,
             section.SecProps, section.WordProps, bSecEnd));
       else
         AddEditUndoItem(new CFXEU_Delete(
             this, m_wpOldCaret, m_wpCaret, word.Word, word.nCharset,
             section.SecProps, word.WordProps, bSecEnd));
     }
 
     if (bPaint) {
       RearrangePart(CPVT_WordRange(m_wpOldCaret, m_wpCaret));
       ScrollToCaret();
       Refresh();
       SetCaretOrigin();
       SetCaretInfo();
     }
 
     if (m_bOprNotify && m_pOprNotify)
       m_pOprNotify->OnDelete(m_wpCaret, m_wpOldCaret);
 
-    return TRUE;
+    return true;
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::Empty() {
+bool CFX_Edit::Empty() {
   if (m_pVT->IsValid()) {
     m_pVT->DeleteWords(GetWholeWordRange());
     SetCaret(m_pVT->GetBeginWordPlace());
 
-    return TRUE;
+    return true;
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::Clear(FX_BOOL bAddUndo, FX_BOOL bPaint) {
+bool CFX_Edit::Clear(bool bAddUndo, bool bPaint) {
   if (!m_pVT->IsValid())
-    return FALSE;
+    return false;
 
   if (!m_SelState.IsExist())
-    return FALSE;
+    return false;
 
   CPVT_WordRange range = m_SelState.ConvertToWordRange();
 
   if (bAddUndo && m_bEnableUndo)
     AddEditUndoItem(new CFXEU_Clear(this, range, GetSelText()));
 
   SelectNone();
   SetCaret(m_pVT->DeleteWords(range));
   m_SelState.Set(m_wpCaret, m_wpCaret);
 
   if (bPaint) {
     RearrangePart(range);
     ScrollToCaret();
     Refresh();
     SetCaretOrigin();
     SetCaretInfo();
   }
 
   if (m_bOprNotify && m_pOprNotify)
     m_pOprNotify->OnClear(m_wpCaret, m_wpOldCaret);
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_Edit::InsertText(const CFX_WideString& sText,
-                             int32_t charset,
-                             FX_BOOL bAddUndo,
-                             FX_BOOL bPaint) {
+bool CFX_Edit::InsertText(const CFX_WideString& sText,
+                          int32_t charset,
+                          bool bAddUndo,
+                          bool bPaint) {
   if (IsTextOverflow())
-    return FALSE;
+    return false;
 
   m_pVT->UpdateWordPlace(m_wpCaret);
   SetCaret(DoInsertText(m_wpCaret, sText, charset));
   m_SelState.Set(m_wpCaret, m_wpCaret);
   if (m_wpCaret == m_wpOldCaret)
-    return FALSE;
+    return false;
 
   if (bAddUndo && m_bEnableUndo) {
     AddEditUndoItem(
         new CFXEU_InsertText(this, m_wpOldCaret, m_wpCaret, sText, charset));
   }
 
   if (bPaint)
     PaintInsertText(m_wpOldCaret, m_wpCaret);
 
   if (m_bOprNotify && m_pOprNotify)
     m_pOprNotify->OnInsertText(m_wpCaret, m_wpOldCaret);
 
-  return TRUE;
+  return true;
 }
 
 void CFX_Edit::PaintInsertText(const CPVT_WordPlace& wpOld,
                                const CPVT_WordPlace& wpNew) {
   if (m_pVT->IsValid()) {
     RearrangePart(CPVT_WordRange(wpOld, wpNew));
     ScrollToCaret();
     Refresh();
     SetCaretOrigin();
     SetCaretInfo();
   }
 }
 
-FX_BOOL CFX_Edit::Redo() {
+bool CFX_Edit::Redo() {
   if (m_bEnableUndo) {
     if (m_Undo.CanRedo()) {
       m_Undo.Redo();
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::Undo() {
+bool CFX_Edit::Undo() {
   if (m_bEnableUndo) {
     if (m_Undo.CanUndo()) {
       m_Undo.Undo();
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
 void CFX_Edit::SetCaretOrigin() {
   if (!m_pVT->IsValid())
     return;
 
   CPDF_VariableText::Iterator* pIterator = m_pVT->GetIterator();
   pIterator->SetAt(m_wpCaret);
   CPVT_Word word;
   CPVT_Line line;
@@ skipping 13 matching lines @@
   return -1;
 }
 
 CPVT_WordPlace CFX_Edit::WordIndexToWordPlace(int32_t index) const {
   if (m_pVT->IsValid())
     return m_pVT->WordIndexToWordPlace(index);
 
   return CPVT_WordPlace();
 }
 
-FX_BOOL CFX_Edit::IsTextFull() const {
+bool CFX_Edit::IsTextFull() const {
   int32_t nTotalWords = m_pVT->GetTotalWords();
   int32_t nLimitChar = m_pVT->GetLimitChar();
   int32_t nCharArray = m_pVT->GetCharArray();
 
   return IsTextOverflow() || (nLimitChar > 0 && nTotalWords >= nLimitChar) ||
          (nCharArray > 0 && nTotalWords >= nCharArray);
 }
 
-FX_BOOL CFX_Edit::IsTextOverflow() const {
+bool CFX_Edit::IsTextOverflow() const {
   if (!m_bEnableScroll && !m_bEnableOverflow) {
     CFX_FloatRect rcPlate = m_pVT->GetPlateRect();
     CFX_FloatRect rcContent = m_pVT->GetContentRect();
 
     if (m_pVT->IsMultiLine() && GetTotalLines() > 1 &&
         IsFloatBigger(rcContent.Height(), rcPlate.Height())) {
-      return TRUE;
+      return true;
     }
 
     if (IsFloatBigger(rcContent.Width(), rcPlate.Width()))
-      return TRUE;
+      return true;
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::CanUndo() const {
+bool CFX_Edit::CanUndo() const {
   if (m_bEnableUndo) {
     return m_Undo.CanUndo();
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CFX_Edit::CanRedo() const {
+bool CFX_Edit::CanRedo() const {
   if (m_bEnableUndo) {
     return m_Undo.CanRedo();
   }
 
-  return FALSE;
+  return false;
 }
 
-void CFX_Edit::EnableRefresh(FX_BOOL bRefresh) {
+void CFX_Edit::EnableRefresh(bool bRefresh) {
   m_bEnableRefresh = bRefresh;
 }
 
-void CFX_Edit::EnableUndo(FX_BOOL bUndo) {
+void CFX_Edit::EnableUndo(bool bUndo) {
   m_bEnableUndo = bUndo;
 }
 
-void CFX_Edit::EnableOprNotify(FX_BOOL bNotify) {
+void CFX_Edit::EnableOprNotify(bool bNotify) {
   m_bOprNotify = bNotify;
 }
 
 CPVT_WordPlace CFX_Edit::DoInsertText(const CPVT_WordPlace& place,
                                       const CFX_WideString& sText,
                                       int32_t charset) {
   CPVT_WordPlace wp = place;
 
   if (m_pVT->IsValid()) {
     for (int32_t i = 0, sz = sText.GetLength(); i < sz; i++) {
@@ skipping 104 matching lines @@
 }
 
 void CFX_Edit_Select::SetBeginPos(const CPVT_WordPlace& begin) {
   BeginPos = begin;
 }
 
 void CFX_Edit_Select::SetEndPos(const CPVT_WordPlace& end) {
   EndPos = end;
 }
 
-FX_BOOL CFX_Edit_Select::IsExist() const {
+bool CFX_Edit_Select::IsExist() const {
   return BeginPos != EndPos;
 }
 
 CFX_Edit_RectArray::CFX_Edit_RectArray() {}
 
 CFX_Edit_RectArray::~CFX_Edit_RectArray() {
   Empty();
 }
 
 void CFX_Edit_RectArray::Empty() {
@@ skipping 17 matching lines @@
 int32_t CFX_Edit_RectArray::GetSize() const {
   return m_Rects.GetSize();
 }
 
 CFX_FloatRect* CFX_Edit_RectArray::GetAt(int32_t nIndex) const {
   if (nIndex < 0 || nIndex >= m_Rects.GetSize())
     return nullptr;
 
   return m_Rects.GetAt(nIndex);
 }