Remove FX_BOOL from fpdfsdk.

fpdfsdk/pdfwindow/PWL_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/pdfwindow/PWL_Edit.h"
 
 #include <vector>
 
 #include "core/fpdfapi/font/cpdf_font.h"
 #include "core/fpdfdoc/cpvt_word.h"
 #include "core/fxcrt/fx_safe_types.h"
 #include "core/fxcrt/fx_xml.h"
 #include "core/fxge/cfx_graphstatedata.h"
 #include "core/fxge/cfx_pathdata.h"
 #include "core/fxge/cfx_renderdevice.h"
 #include "core/fxge/fx_font.h"
 #include "fpdfsdk/fxedit/fxet_edit.h"
 #include "fpdfsdk/pdfwindow/PWL_Caret.h"
 #include "fpdfsdk/pdfwindow/PWL_EditCtrl.h"
 #include "fpdfsdk/pdfwindow/PWL_FontMap.h"
 #include "fpdfsdk/pdfwindow/PWL_ScrollBar.h"
 #include "fpdfsdk/pdfwindow/PWL_Utils.h"
 #include "fpdfsdk/pdfwindow/PWL_Wnd.h"
 #include "public/fpdf_fwlevent.h"
 #include "third_party/base/stl_util.h"
 
 CPWL_Edit::CPWL_Edit()
-    : m_pFillerNotify(nullptr), m_bFocus(FALSE), m_pFormFiller(nullptr) {}
+    : m_pFillerNotify(nullptr), m_bFocus(false), m_pFormFiller(nullptr) {}
 
 CPWL_Edit::~CPWL_Edit() {
-  ASSERT(m_bFocus == FALSE);
+  ASSERT(m_bFocus == false);
 }
 
 CFX_ByteString CPWL_Edit::GetClassName() const {
   return PWL_CLASSNAME_EDIT;
 }
 
 void CPWL_Edit::OnDestroy() {}
 
 void CPWL_Edit::SetText(const CFX_WideString& csText) {
   CFX_WideString swText = csText;
   if (HasFlag(PES_RICH)) {
     CFX_ByteString sValue = CFX_ByteString::FromUnicode(swText);
     if (CXML_Element* pXML =
             CXML_Element::Parse(sValue.c_str(), sValue.GetLength())) {
       int32_t nCount = pXML->CountChildren();
-      FX_BOOL bFirst = TRUE;
+      bool bFirst = true;
 
       swText.clear();
 
       for (int32_t i = 0; i < nCount; i++) {
         if (CXML_Element* pSubElement = pXML->GetElement(i)) {
           CFX_ByteString tag = pSubElement->GetTagName();
           if (tag.EqualNoCase("p")) {
             int nChild = pSubElement->CountChildren();
             CFX_WideString swSection;
             for (int32_t j = 0; j < nChild; j++) {
               swSection += pSubElement->GetContent(j);
             }
 
             if (bFirst)
-              bFirst = FALSE;
+              bFirst = false;
             else
               swText += FWL_VKEY_Return;
             swText += swSection;
           }
         }
       }
 
       delete pXML;
     }
   }
 
   m_pEdit->SetText(swText);
 }
 
 void CPWL_Edit::RePosChildWnd() {
   if (CPWL_ScrollBar* pVSB = GetVScrollBar()) {
     CFX_FloatRect rcWindow = m_rcOldWindow;
     CFX_FloatRect rcVScroll =
         CFX_FloatRect(rcWindow.right, rcWindow.bottom,
                       rcWindow.right + PWL_SCROLLBAR_WIDTH, rcWindow.top);
-    pVSB->Move(rcVScroll, TRUE, FALSE);
+    pVSB->Move(rcVScroll, true, false);
   }
 
   if (m_pEditCaret && !HasFlag(PES_TEXTOVERFLOW))
     m_pEditCaret->SetClipRect(CPWL_Utils::InflateRect(
         GetClientRect(), 1.0f));  // +1 for caret beside border
 
   CPWL_EditCtrl::RePosChildWnd();
 }
 
 CFX_FloatRect CPWL_Edit::GetClientRect() const {
   CFX_FloatRect rcClient = CPWL_Utils::DeflateRect(
       GetWindowRect(), (FX_FLOAT)(GetBorderWidth() + GetInnerBorderWidth()));
 
   if (CPWL_ScrollBar* pVSB = GetVScrollBar()) {
     if (pVSB->IsVisible()) {
       rcClient.right -= PWL_SCROLLBAR_WIDTH;
     }
   }
 
   return rcClient;
 }
 
-void CPWL_Edit::SetAlignFormatV(PWL_EDIT_ALIGNFORMAT_V nFormat,
-                                FX_BOOL bPaint) {
+void CPWL_Edit::SetAlignFormatV(PWL_EDIT_ALIGNFORMAT_V nFormat, bool bPaint) {
   m_pEdit->SetAlignmentV((int32_t)nFormat, bPaint);
 }
 
-FX_BOOL CPWL_Edit::CanSelectAll() const {
+bool CPWL_Edit::CanSelectAll() const {
   return GetSelectWordRange() != m_pEdit->GetWholeWordRange();
 }
 
-FX_BOOL CPWL_Edit::CanClear() const {
+bool CPWL_Edit::CanClear() const {
   return !IsReadOnly() && m_pEdit->IsSelected();
 }
 
-FX_BOOL CPWL_Edit::CanCopy() const {
+bool CPWL_Edit::CanCopy() const {
   return !HasFlag(PES_PASSWORD) && !HasFlag(PES_NOREAD) &&
          m_pEdit->IsSelected();
 }
 
-FX_BOOL CPWL_Edit::CanCut() const {
+bool CPWL_Edit::CanCut() const {
   return CanCopy() && !IsReadOnly();
 }
 void CPWL_Edit::CutText() {
   if (!CanCut())
     return;
   m_pEdit->Clear();
 }
 
 void CPWL_Edit::OnCreated() {
   CPWL_EditCtrl::OnCreated();
 
   if (CPWL_ScrollBar* pScroll = GetVScrollBar()) {
     pScroll->RemoveFlag(PWS_AUTOTRANSPARENT);
     pScroll->SetTransparency(255);
   }
 
   SetParamByFlag();
 
   m_rcOldWindow = GetWindowRect();
 
   m_pEdit->SetOprNotify(this);
-  m_pEdit->EnableOprNotify(TRUE);
+  m_pEdit->EnableOprNotify(true);
 }
 
 void CPWL_Edit::SetParamByFlag() {
   if (HasFlag(PES_RIGHT)) {
-    m_pEdit->SetAlignmentH(2, FALSE);
+    m_pEdit->SetAlignmentH(2, false);
   } else if (HasFlag(PES_MIDDLE)) {
-    m_pEdit->SetAlignmentH(1, FALSE);
+    m_pEdit->SetAlignmentH(1, false);
   } else {
-    m_pEdit->SetAlignmentH(0, FALSE);
+    m_pEdit->SetAlignmentH(0, false);
   }
 
   if (HasFlag(PES_BOTTOM)) {
-    m_pEdit->SetAlignmentV(2, FALSE);
+    m_pEdit->SetAlignmentV(2, false);
   } else if (HasFlag(PES_CENTER)) {
-    m_pEdit->SetAlignmentV(1, FALSE);
+    m_pEdit->SetAlignmentV(1, false);
   } else {
-    m_pEdit->SetAlignmentV(0, FALSE);
+    m_pEdit->SetAlignmentV(0, false);
   }
 
   if (HasFlag(PES_PASSWORD)) {
-    m_pEdit->SetPasswordChar('*', FALSE);
+    m_pEdit->SetPasswordChar('*', false);
   }
 
-  m_pEdit->SetMultiLine(HasFlag(PES_MULTILINE), FALSE);
-  m_pEdit->SetAutoReturn(HasFlag(PES_AUTORETURN), FALSE);
-  m_pEdit->SetAutoFontSize(HasFlag(PWS_AUTOFONTSIZE), FALSE);
-  m_pEdit->SetAutoScroll(HasFlag(PES_AUTOSCROLL), FALSE);
+  m_pEdit->SetMultiLine(HasFlag(PES_MULTILINE), false);
+  m_pEdit->SetAutoReturn(HasFlag(PES_AUTORETURN), false);
+  m_pEdit->SetAutoFontSize(HasFlag(PWS_AUTOFONTSIZE), false);
+  m_pEdit->SetAutoScroll(HasFlag(PES_AUTOSCROLL), false);
   m_pEdit->EnableUndo(HasFlag(PES_UNDO));
 
   if (HasFlag(PES_TEXTOVERFLOW)) {
     SetClipRect(CFX_FloatRect(0.0f, 0.0f, 0.0f, 0.0f));
-    m_pEdit->SetTextOverflow(TRUE, FALSE);
+    m_pEdit->SetTextOverflow(true, false);
   } else {
     if (m_pEditCaret) {
       m_pEditCaret->SetClipRect(CPWL_Utils::InflateRect(
           GetClientRect(), 1.0f));  // +1 for caret beside border
     }
   }
 }
 
 void CPWL_Edit::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
   CPWL_Wnd::GetThisAppearanceStream(sAppStream);
 
   CFX_FloatRect rcClient = GetClientRect();
   CFX_ByteTextBuf sLine;
 
   int32_t nCharArray = m_pEdit->GetCharArray();
 
   if (nCharArray > 0) {
     switch (GetBorderStyle()) {
       case BorderStyle::SOLID: {
-        sLine << "q\n" << GetBorderWidth() << " w\n"
-              << CPWL_Utils::GetColorAppStream(GetBorderColor(), FALSE)
+        sLine << "q\n"
+              << GetBorderWidth() << " w\n"
+              << CPWL_Utils::GetColorAppStream(GetBorderColor(), false)
                      .AsStringC()
               << " 2 J 0 j\n";
 
         for (int32_t i = 1; i < nCharArray; i++) {
           sLine << rcClient.left +
                        ((rcClient.right - rcClient.left) / nCharArray) * i
                 << " " << rcClient.bottom << " m\n"
                 << rcClient.left +
                        ((rcClient.right - rcClient.left) / nCharArray) * i
                 << " " << rcClient.top << " l S\n";
         }
 
         sLine << "Q\n";
         break;
       }
       case BorderStyle::DASH: {
-        sLine << "q\n" << GetBorderWidth() << " w\n"
-              << CPWL_Utils::GetColorAppStream(GetBorderColor(), FALSE)
+        sLine << "q\n"
+              << GetBorderWidth() << " w\n"
+              << CPWL_Utils::GetColorAppStream(GetBorderColor(), false)
                      .AsStringC()
               << " 2 J 0 j\n"
               << "[" << GetBorderDash().nDash << " " << GetBorderDash().nGap
               << "] " << GetBorderDash().nPhase << " d\n";
 
         for (int32_t i = 1; i < nCharArray; i++) {
           sLine << rcClient.left +
                        ((rcClient.right - rcClient.left) / nCharArray) * i
                 << " " << rcClient.bottom << " m\n"
                 << rcClient.left +
@@ skipping 160 matching lines @@
   }
 
   CFX_SystemHandler* pSysHandler = GetSystemHandler();
   CFX_Edit::DrawEdit(
       pDevice, pUser2Device, m_pEdit.get(),
       CPWL_Utils::PWLColorToFXColor(GetTextColor(), GetTransparency()),
       CPWL_Utils::PWLColorToFXColor(GetTextStrokeColor(), GetTransparency()),
       rcClip, CFX_FloatPoint(), pRange, pSysHandler, m_pFormFiller);
 }
 
-FX_BOOL CPWL_Edit::OnLButtonDown(const CFX_FloatPoint& point, uint32_t nFlag) {
+bool CPWL_Edit::OnLButtonDown(const CFX_FloatPoint& point, uint32_t nFlag) {
   CPWL_Wnd::OnLButtonDown(point, nFlag);
 
   if (HasFlag(PES_TEXTOVERFLOW) || ClientHitTest(point)) {
     if (m_bMouseDown)
       InvalidateRect();
 
-    m_bMouseDown = TRUE;
+    m_bMouseDown = true;
     SetCapture();
 
     m_pEdit->OnMouseDown(point, IsSHIFTpressed(nFlag), IsCTRLpressed(nFlag));
   }
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPWL_Edit::OnLButtonDblClk(const CFX_FloatPoint& point,
-                                   uint32_t nFlag) {
+bool CPWL_Edit::OnLButtonDblClk(const CFX_FloatPoint& point, uint32_t nFlag) {
   CPWL_Wnd::OnLButtonDblClk(point, nFlag);
 
   if (HasFlag(PES_TEXTOVERFLOW) || ClientHitTest(point)) {
     m_pEdit->SelectAll();
   }
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPWL_Edit::OnRButtonUp(const CFX_FloatPoint& point, uint32_t nFlag) {
+bool CPWL_Edit::OnRButtonUp(const CFX_FloatPoint& point, uint32_t nFlag) {
   if (m_bMouseDown)
-    return FALSE;
+    return false;
 
   CPWL_Wnd::OnRButtonUp(point, nFlag);
 
   if (!HasFlag(PES_TEXTOVERFLOW) && !ClientHitTest(point))
-    return TRUE;
+    return true;
 
   CFX_SystemHandler* pSH = GetSystemHandler();
   if (!pSH)
-    return FALSE;
+    return false;
 
   SetFocus();
 
-  return FALSE;
+  return false;
 }
 
 void CPWL_Edit::OnSetFocus() {
-  SetEditCaret(TRUE);
+  SetEditCaret(true);
   if (!IsReadOnly()) {
     if (IPWL_FocusHandler* pFocusHandler = GetFocusHandler())
       pFocusHandler->OnSetFocus(this);
   }
-  m_bFocus = TRUE;
+  m_bFocus = true;
 }
 
 void CPWL_Edit::OnKillFocus() {
-  ShowVScrollBar(FALSE);
+  ShowVScrollBar(false);
   m_pEdit->SelectNone();
-  SetCaret(FALSE, CFX_FloatPoint(), CFX_FloatPoint());
+  SetCaret(false, CFX_FloatPoint(), CFX_FloatPoint());
   SetCharSet(FXFONT_ANSI_CHARSET);
-  m_bFocus = FALSE;
+  m_bFocus = false;
 }
 
 void CPWL_Edit::SetCharSpace(FX_FLOAT fCharSpace) {
   m_pEdit->SetCharSpace(fCharSpace);
 }
 
 CFX_ByteString CPWL_Edit::GetSelectAppearanceStream(
     const CFX_FloatPoint& ptOffset) const {
   CPVT_WordRange wr = GetSelectWordRange();
   return CPWL_Utils::GetEditSelAppStream(m_pEdit.get(), ptOffset, &wr);
@@ skipping 43 matching lines @@
   CFX_FloatPoint pt;
   CPVT_Word word;
   if (pIterator->GetWord(word)) {
     pt = CFX_FloatPoint(word.ptWord.x + word.fWidth,
                         word.ptWord.y + word.fDescent);
   }
   pIterator->SetAt(wpOld);
   return pt;
 }
 
-FX_BOOL CPWL_Edit::IsTextFull() const {
+bool CPWL_Edit::IsTextFull() const {
   return m_pEdit->IsTextFull();
 }
 
 FX_FLOAT CPWL_Edit::GetCharArrayAutoFontSize(CPDF_Font* pFont,
                                              const CFX_FloatRect& rcPlate,
                                              int32_t nCharArray) {
   if (pFont && !pFont->IsStandardFont()) {
     FX_RECT rcBBox;
     pFont->GetFontBBox(rcBBox);
 
     CFX_FloatRect rcCell = rcPlate;
     FX_FLOAT xdiv = rcCell.Width() / nCharArray * 1000.0f / rcBBox.Width();
     FX_FLOAT ydiv = -rcCell.Height() * 1000.0f / rcBBox.Height();
 
     return xdiv < ydiv ? xdiv : ydiv;
   }
 
   return 0.0f;
 }
 
 void CPWL_Edit::SetCharArray(int32_t nCharArray) {
   if (HasFlag(PES_CHARARRAY) && nCharArray > 0) {
     m_pEdit->SetCharArray(nCharArray);
-    m_pEdit->SetTextOverflow(TRUE, TRUE);
+    m_pEdit->SetTextOverflow(true, true);
 
     if (HasFlag(PWS_AUTOFONTSIZE)) {
       if (IPVT_FontMap* pFontMap = GetFontMap()) {
         FX_FLOAT fFontSize = GetCharArrayAutoFontSize(
             pFontMap->GetPDFFont(0), GetClientRect(), nCharArray);
         if (fFontSize > 0.0f) {
-          m_pEdit->SetAutoFontSize(FALSE, TRUE);
+          m_pEdit->SetAutoFontSize(false, true);
           m_pEdit->SetFontSize(fFontSize);
         }
       }
     }
   }
 }
 
 void CPWL_Edit::SetLimitChar(int32_t nLimitChar) {
   m_pEdit->SetLimitChar(nLimitChar);
 }
 
 void CPWL_Edit::ReplaceSel(const CFX_WideString& wsText) {
   m_pEdit->Clear();
   m_pEdit->InsertText(wsText, FXFONT_DEFAULT_CHARSET);
 }
 
 CFX_FloatRect CPWL_Edit::GetFocusRect() const {
   return CFX_FloatRect();
 }
 
-void CPWL_Edit::ShowVScrollBar(FX_BOOL bShow) {
+void CPWL_Edit::ShowVScrollBar(bool bShow) {
   if (CPWL_ScrollBar* pScroll = GetVScrollBar()) {
     if (bShow) {
       if (!pScroll->IsVisible()) {
-        pScroll->SetVisible(TRUE);
+        pScroll->SetVisible(true);
         CFX_FloatRect rcWindow = GetWindowRect();
         m_rcOldWindow = rcWindow;
         rcWindow.right += PWL_SCROLLBAR_WIDTH;
-        Move(rcWindow, TRUE, TRUE);
+        Move(rcWindow, true, true);
       }
     } else {
       if (pScroll->IsVisible()) {
-        pScroll->SetVisible(FALSE);
-        Move(m_rcOldWindow, TRUE, TRUE);
+        pScroll->SetVisible(false);
+        Move(m_rcOldWindow, true, true);
       }
     }
   }
 }
 
-FX_BOOL CPWL_Edit::IsVScrollBarVisible() const {
+bool CPWL_Edit::IsVScrollBarVisible() const {
   if (CPWL_ScrollBar* pScroll = GetVScrollBar()) {
     return pScroll->IsVisible();
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPWL_Edit::OnKeyDown(uint16_t nChar, uint32_t nFlag) {
+bool CPWL_Edit::OnKeyDown(uint16_t nChar, uint32_t nFlag) {
   if (m_bMouseDown)
-    return TRUE;
+    return true;
 
   if (nChar == FWL_VKEY_Delete) {
     if (m_pFillerNotify) {
-      FX_BOOL bRC = TRUE;
-      FX_BOOL bExit = FALSE;
+      bool bRC = true;
+      bool bExit = false;
       CFX_WideString strChange;
       CFX_WideString strChangeEx;
 
       int nSelStart = 0;
       int nSelEnd = 0;
       GetSel(nSelStart, nSelEnd);
 
       if (nSelStart == nSelEnd)
         nSelEnd = nSelStart + 1;
       m_pFillerNotify->OnBeforeKeyStroke(GetAttachedData(), strChange,
-                                         strChangeEx, nSelStart, nSelEnd, TRUE,
+                                         strChangeEx, nSelStart, nSelEnd, true,
                                          bRC, bExit, nFlag);
       if (!bRC)
-        return FALSE;
+        return false;
       if (bExit)
-        return FALSE;
+        return false;
     }
   }
 
-  FX_BOOL bRet = CPWL_EditCtrl::OnKeyDown(nChar, nFlag);
+  bool bRet = CPWL_EditCtrl::OnKeyDown(nChar, nFlag);
 
   // In case of implementation swallow the OnKeyDown event.
   if (IsProceedtoOnChar(nChar, nFlag))
-    return TRUE;
+    return true;
 
   return bRet;
 }
 
 /**
 *In case of implementation swallow the OnKeyDown event.
 *If the event is swallowed, implementation may do other unexpected things, which
 *is not the control means to do.
 */
-FX_BOOL CPWL_Edit::IsProceedtoOnChar(uint16_t nKeyCode, uint32_t nFlag) {
-  FX_BOOL bCtrl = IsCTRLpressed(nFlag);
-  FX_BOOL bAlt = IsALTpressed(nFlag);
+bool CPWL_Edit::IsProceedtoOnChar(uint16_t nKeyCode, uint32_t nFlag) {
+  bool bCtrl = IsCTRLpressed(nFlag);
+  bool bAlt = IsALTpressed(nFlag);
   if (bCtrl && !bAlt) {
     // hot keys for edit control.
     switch (nKeyCode) {
       case 'C':
       case 'V':
       case 'X':
       case 'A':
       case 'Z':
-        return TRUE;
+        return true;
       default:
         break;
     }
   }
   // control characters.
   switch (nKeyCode) {
     case FWL_VKEY_Escape:
     case FWL_VKEY_Back:
     case FWL_VKEY_Return:
     case FWL_VKEY_Space:
-      return TRUE;
+      return true;
     default:
-      return FALSE;
+      return false;
   }
 }
 
-FX_BOOL CPWL_Edit::OnChar(uint16_t nChar, uint32_t nFlag) {
+bool CPWL_Edit::OnChar(uint16_t nChar, uint32_t nFlag) {
   if (m_bMouseDown)
-    return TRUE;
+    return true;
 
-  FX_BOOL bRC = TRUE;
-  FX_BOOL bExit = FALSE;
+  bool bRC = true;
+  bool bExit = false;
 
   if (!IsCTRLpressed(nFlag)) {
     if (m_pFillerNotify) {
       CFX_WideString swChange;
 
       int nSelStart = 0;
       int nSelEnd = 0;
       GetSel(nSelStart, nSelEnd);
 
       switch (nChar) {
         case FWL_VKEY_Back:
           if (nSelStart == nSelEnd)
             nSelStart = nSelEnd - 1;
           break;
         case FWL_VKEY_Return:
           break;
         default:
           swChange += nChar;
           break;
       }
 
       CFX_WideString strChangeEx;
       m_pFillerNotify->OnBeforeKeyStroke(GetAttachedData(), swChange,
-                                         strChangeEx, nSelStart, nSelEnd, TRUE,
+                                         strChangeEx, nSelStart, nSelEnd, true,
                                          bRC, bExit, nFlag);
     }
   }
 
   if (!bRC)
-    return TRUE;
+    return true;
   if (bExit)
-    return FALSE;
+    return false;
 
   if (IPVT_FontMap* pFontMap = GetFontMap()) {
     int32_t nOldCharSet = GetCharSet();
     int32_t nNewCharSet =
         pFontMap->CharSetFromUnicode(nChar, FXFONT_DEFAULT_CHARSET);
     if (nOldCharSet != nNewCharSet) {
       SetCharSet(nNewCharSet);
     }
   }
 
   return CPWL_EditCtrl::OnChar(nChar, nFlag);
 }
 
-FX_BOOL CPWL_Edit::OnMouseWheel(short zDelta,
-                                const CFX_FloatPoint& point,
-                                uint32_t nFlag) {
+bool CPWL_Edit::OnMouseWheel(short zDelta,
+                             const CFX_FloatPoint& point,
+                             uint32_t nFlag) {
   if (HasFlag(PES_MULTILINE)) {
     CFX_FloatPoint ptScroll = GetScrollPos();
 
     if (zDelta > 0) {
       ptScroll.y += GetFontSize();
     } else {
       ptScroll.y -= GetFontSize();
     }
     SetScrollPos(ptScroll);
 
-    return TRUE;
+    return true;
   }
 
-  return FALSE;
+  return false;
 }
 
 void CPWL_Edit::OnInsertReturn(const CPVT_WordPlace& place,
                                const CPVT_WordPlace& oldplace) {
   if (HasFlag(PES_SPELLCHECK)) {
     m_pEdit->RefreshWordRange(CombineWordRange(GetLatinWordsRange(oldplace),
                                                GetLatinWordsRange(place)));
   }
 }
 
@@ skipping 51 matching lines @@
     wrRet.EndPos = wr2.EndPos;
   } else {
     wrRet.EndPos = wr1.EndPos;
   }
 
   return wrRet;
 }
 
 CPVT_WordRange CPWL_Edit::GetLatinWordsRange(
     const CFX_FloatPoint& point) const {
-  return GetSameWordsRange(m_pEdit->SearchWordPlace(point), TRUE, FALSE);
+  return GetSameWordsRange(m_pEdit->SearchWordPlace(point), true, false);
 }
 
 CPVT_WordRange CPWL_Edit::GetLatinWordsRange(
     const CPVT_WordPlace& place) const {
-  return GetSameWordsRange(place, TRUE, FALSE);
+  return GetSameWordsRange(place, true, false);
 }
 
 CPVT_WordRange CPWL_Edit::GetArabicWordsRange(
     const CPVT_WordPlace& place) const {
-  return GetSameWordsRange(place, FALSE, TRUE);
+  return GetSameWordsRange(place, false, true);
 }
 
 #define PWL_ISARABICWORD(word) \
   ((word >= 0x0600 && word <= 0x06FF) || (word >= 0xFB50 && word <= 0xFEFC))
 
 CPVT_WordRange CPWL_Edit::GetSameWordsRange(const CPVT_WordPlace& place,
-                                            FX_BOOL bLatin,
-                                            FX_BOOL bArabic) const {
+                                            bool bLatin,
+                                            bool bArabic) const {
   CPVT_WordRange range;
 
   CFX_Edit_Iterator* pIterator = m_pEdit->GetIterator();
   CPVT_Word wordinfo;
   CPVT_WordPlace wpStart(place), wpEnd(place);
   pIterator->SetAt(place);
 
   if (bLatin) {
     while (pIterator->NextWord()) {
       if (!pIterator->GetWord(wordinfo) ||
@@ skipping 47 matching lines @@
 }
 
 void CPWL_Edit::GeneratePageObjects(CPDF_PageObjectHolder* pObjectHolder,
                                     const CFX_FloatPoint& ptOffset) {
   CFX_ArrayTemplate<CPDF_TextObject*> ObjArray;
   CFX_Edit::GeneratePageObjects(
       pObjectHolder, m_pEdit.get(), ptOffset, nullptr,
       CPWL_Utils::PWLColorToFXColor(GetTextColor(), GetTransparency()),
       ObjArray);
 }