Remove FX_BOOL from fpdfsdk.

fpdfsdk/fxedit/fxet_list.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_list.h"
 
 #include "core/fpdfdoc/cpvt_word.h"
 #include "fpdfsdk/fxedit/fxet_edit.h"
 #include "fpdfsdk/pdfwindow/PWL_ListBox.h"
 
 CFX_ListItem::CFX_ListItem()
     : m_pEdit(new CFX_Edit),
-      m_bSelected(FALSE),
+      m_bSelected(false),
       m_rcListItem(0.0f, 0.0f, 0.0f, 0.0f) {
-  m_pEdit->SetAlignmentV(1, TRUE);
+  m_pEdit->SetAlignmentV(1, true);
   m_pEdit->Initialize();
 }
 
 CFX_ListItem::~CFX_ListItem() {
 }
 
 void CFX_ListItem::SetFontMap(IPVT_FontMap* pFontMap) {
   m_pEdit->SetFontMap(pFontMap);
 }
 
 CFX_Edit* CFX_ListItem::GetEdit() const {
   return m_pEdit.get();
 }
 
 CFX_Edit_Iterator* CFX_ListItem::GetIterator() const {
   return m_pEdit->GetIterator();
 }
 
 void CFX_ListItem::SetRect(const CLST_Rect& rect) {
   m_rcListItem = rect;
 }
 
 CLST_Rect CFX_ListItem::GetRect() const {
   return m_rcListItem;
 }
 
-FX_BOOL CFX_ListItem::IsSelected() const {
+bool CFX_ListItem::IsSelected() const {
   return m_bSelected;
 }
 
-void CFX_ListItem::SetSelect(FX_BOOL bSelected) {
+void CFX_ListItem::SetSelect(bool bSelected) {
   m_bSelected = bSelected;
 }
 
 void CFX_ListItem::SetText(const CFX_WideString& text) {
   m_pEdit->SetText(text);
 }
 
 void CFX_ListItem::SetFontSize(FX_FLOAT fFontSize) {
   m_pEdit->SetFontSize(fFontSize);
 }
@@ skipping 77 matching lines @@
   for (int32_t i = 0, sz = m_aItems.GetSize(); i < sz; i++) {
     if (CPLST_Select_Item* pItem = m_aItems.GetAt(i)) {
       if (pItem->nItemIndex == nItemIndex)
         return i;
     }
   }
 
   return -1;
 }
 
-FX_BOOL CPLST_Select::IsExist(int32_t nItemIndex) const {
+bool CPLST_Select::IsExist(int32_t nItemIndex) const {
   return Find(nItemIndex) >= 0;
 }
 
 int32_t CPLST_Select::GetCount() const {
   return m_aItems.GetSize();
 }
 
 int32_t CPLST_Select::GetItemIndex(int32_t nIndex) const {
   if (nIndex >= 0 && nIndex < m_aItems.GetSize())
     if (CPLST_Select_Item* pItem = m_aItems.GetAt(nIndex))
@@ skipping 26 matching lines @@
         m_aItems.RemoveAt(i);
       } else {
         pItem->nState = 0;
       }
     }
   }
 }
 
 CFX_ListCtrl::CFX_ListCtrl()
     : m_pNotify(nullptr),
-      m_bNotifyFlag(FALSE),
+      m_bNotifyFlag(false),
       m_nSelItem(-1),
       m_nFootIndex(-1),
-      m_bCtrlSel(FALSE),
+      m_bCtrlSel(false),
       m_nCaretIndex(-1),
       m_fFontSize(0.0f),
       m_pFontMap(nullptr),
-      m_bMultiple(FALSE) {}
+      m_bMultiple(false) {}
 
 CFX_ListCtrl::~CFX_ListCtrl() {
   Empty();
 }
 
 void CFX_ListCtrl::SetNotify(CPWL_List_Notify* pNotify) {
   m_pNotify = pNotify;
 }
 
 CFX_FloatPoint CFX_ListCtrl::InToOut(const CFX_FloatPoint& point) const {
@@ skipping 20 matching lines @@
 
 CFX_FloatRect CFX_ListCtrl::OutToIn(const CFX_FloatRect& rect) const {
   CFX_FloatPoint ptLeftBottom = OutToIn(CFX_FloatPoint(rect.left, rect.bottom));
   CFX_FloatPoint ptRightTop = OutToIn(CFX_FloatPoint(rect.right, rect.top));
 
   return CFX_FloatRect(ptLeftBottom.x, ptLeftBottom.y, ptRightTop.x,
                        ptRightTop.y);
 }
 
 void CFX_ListCtrl::OnMouseDown(const CFX_FloatPoint& point,
-                               FX_BOOL bShift,
-                               FX_BOOL bCtrl) {
+                               bool bShift,
+                               bool bCtrl) {
   int32_t nHitIndex = GetItemIndex(point);
 
   if (IsMultipleSel()) {
     if (bCtrl) {
       if (IsItemSelected(nHitIndex)) {
         m_aSelItems.Sub(nHitIndex);
         SelectItems();
-        m_bCtrlSel = FALSE;
+        m_bCtrlSel = false;
       } else {
         m_aSelItems.Add(nHitIndex);
         SelectItems();
-        m_bCtrlSel = TRUE;
+        m_bCtrlSel = true;
       }
 
       m_nFootIndex = nHitIndex;
     } else if (bShift) {
       m_aSelItems.DeselectAll();
       m_aSelItems.Add(m_nFootIndex, nHitIndex);
       SelectItems();
     } else {
       m_aSelItems.DeselectAll();
       m_aSelItems.Add(nHitIndex);
       SelectItems();
 
       m_nFootIndex = nHitIndex;
     }
 
     SetCaret(nHitIndex);
   } else {
     SetSingleSelect(nHitIndex);
   }
 
   if (!IsItemVisible(nHitIndex))
     ScrollToListItem(nHitIndex);
 }
 
 void CFX_ListCtrl::OnMouseMove(const CFX_FloatPoint& point,
-                               FX_BOOL bShift,
-                               FX_BOOL bCtrl) {
+                               bool bShift,
+                               bool bCtrl) {
   int32_t nHitIndex = GetItemIndex(point);
 
   if (IsMultipleSel()) {
     if (bCtrl) {
       if (m_bCtrlSel)
         m_aSelItems.Add(m_nFootIndex, nHitIndex);
       else
         m_aSelItems.Sub(m_nFootIndex, nHitIndex);
 
       SelectItems();
     } else {
       m_aSelItems.DeselectAll();
       m_aSelItems.Add(m_nFootIndex, nHitIndex);
       SelectItems();
     }
 
     SetCaret(nHitIndex);
   } else {
     SetSingleSelect(nHitIndex);
   }
 
   if (!IsItemVisible(nHitIndex))
     ScrollToListItem(nHitIndex);
 }
 
-void CFX_ListCtrl::OnVK(int32_t nItemIndex, FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK(int32_t nItemIndex, bool bShift, bool bCtrl) {
   if (IsMultipleSel()) {
     if (nItemIndex >= 0 && nItemIndex < GetCount()) {
       if (bCtrl) {
       } else if (bShift) {
         m_aSelItems.DeselectAll();
         m_aSelItems.Add(m_nFootIndex, nItemIndex);
         SelectItems();
       } else {
         m_aSelItems.DeselectAll();
         m_aSelItems.Add(nItemIndex);
         SelectItems();
         m_nFootIndex = nItemIndex;
       }
 
       SetCaret(nItemIndex);
     }
   } else {
     SetSingleSelect(nItemIndex);
   }
 
   if (!IsItemVisible(nItemIndex))
     ScrollToListItem(nItemIndex);
 }
 
-void CFX_ListCtrl::OnVK_UP(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_UP(bool bShift, bool bCtrl) {
   OnVK(IsMultipleSel() ? GetCaret() - 1 : GetSelect() - 1, bShift, bCtrl);
 }
 
-void CFX_ListCtrl::OnVK_DOWN(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_DOWN(bool bShift, bool bCtrl) {
   OnVK(IsMultipleSel() ? GetCaret() + 1 : GetSelect() + 1, bShift, bCtrl);
 }
 
-void CFX_ListCtrl::OnVK_LEFT(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_LEFT(bool bShift, bool bCtrl) {
   OnVK(0, bShift, bCtrl);
 }
 
-void CFX_ListCtrl::OnVK_RIGHT(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_RIGHT(bool bShift, bool bCtrl) {
   OnVK(GetCount() - 1, bShift, bCtrl);
 }
 
-void CFX_ListCtrl::OnVK_HOME(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_HOME(bool bShift, bool bCtrl) {
   OnVK(0, bShift, bCtrl);
 }
 
-void CFX_ListCtrl::OnVK_END(FX_BOOL bShift, FX_BOOL bCtrl) {
+void CFX_ListCtrl::OnVK_END(bool bShift, bool bCtrl) {
   OnVK(GetCount() - 1, bShift, bCtrl);
 }
 
-FX_BOOL CFX_ListCtrl::OnChar(uint16_t nChar, FX_BOOL bShift, FX_BOOL bCtrl) {
+bool CFX_ListCtrl::OnChar(uint16_t nChar, bool bShift, bool bCtrl) {
   int32_t nIndex = GetLastSelected();
   int32_t nFindIndex = FindNext(nIndex, nChar);
 
   if (nFindIndex != nIndex) {
     OnVK(nFindIndex, bShift, bCtrl);
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 void CFX_ListCtrl::SetPlateRect(const CFX_FloatRect& rect) {
   CFX_ListContainer::SetPlateRect(rect);
   m_ptScrollPos.x = rect.left;
   SetScrollPos(CFX_FloatPoint(rect.left, rect.top));
   ReArrange(0);
   InvalidateItem(-1);
 }
 
@@ skipping 18 matching lines @@
 
 int32_t CFX_ListCtrl::GetSelect() const {
   return m_nSelItem;
 }
 
 void CFX_ListCtrl::AddString(const CFX_WideString& str) {
   AddItem(str);
   ReArrange(GetCount() - 1);
 }
 
-void CFX_ListCtrl::SetMultipleSelect(int32_t nItemIndex, FX_BOOL bSelected) {
+void CFX_ListCtrl::SetMultipleSelect(int32_t nItemIndex, bool bSelected) {
   if (!IsValid(nItemIndex))
     return;
 
   if (bSelected != IsItemSelected(nItemIndex)) {
     if (bSelected) {
-      SetItemSelect(nItemIndex, TRUE);
+      SetItemSelect(nItemIndex, true);
       InvalidateItem(nItemIndex);
     } else {
-      SetItemSelect(nItemIndex, FALSE);
+      SetItemSelect(nItemIndex, false);
       InvalidateItem(nItemIndex);
     }
   }
 }
 
 void CFX_ListCtrl::SetSingleSelect(int32_t nItemIndex) {
   if (!IsValid(nItemIndex))
     return;
 
   if (m_nSelItem != nItemIndex) {
     if (m_nSelItem >= 0) {
-      SetItemSelect(m_nSelItem, FALSE);
+      SetItemSelect(m_nSelItem, false);
       InvalidateItem(m_nSelItem);
     }
 
-    SetItemSelect(nItemIndex, TRUE);
+    SetItemSelect(nItemIndex, true);
     InvalidateItem(nItemIndex);
     m_nSelItem = nItemIndex;
   }
 }
 
 void CFX_ListCtrl::SetCaret(int32_t nItemIndex) {
   if (!IsValid(nItemIndex))
     return;
 
   if (IsMultipleSel()) {
     int32_t nOldIndex = m_nCaretIndex;
 
     if (nOldIndex != nItemIndex) {
       m_nCaretIndex = nItemIndex;
       InvalidateItem(nOldIndex);
       InvalidateItem(nItemIndex);
     }
   }
 }
 
 void CFX_ListCtrl::InvalidateItem(int32_t nItemIndex) {
   if (m_pNotify) {
     if (nItemIndex == -1) {
       if (!m_bNotifyFlag) {
-        m_bNotifyFlag = TRUE;
+        m_bNotifyFlag = true;
         CFX_FloatRect rcRefresh = GetPlateRect();
         m_pNotify->IOnInvalidateRect(&rcRefresh);
-        m_bNotifyFlag = FALSE;
+        m_bNotifyFlag = false;
       }
     } else {
       if (!m_bNotifyFlag) {
-        m_bNotifyFlag = TRUE;
+        m_bNotifyFlag = true;
         CFX_FloatRect rcRefresh = GetItemRect(nItemIndex);
         rcRefresh.left -= 1.0f;
         rcRefresh.right += 1.0f;
         rcRefresh.bottom -= 1.0f;
         rcRefresh.top += 1.0f;
 
         m_pNotify->IOnInvalidateRect(&rcRefresh);
-        m_bNotifyFlag = FALSE;
+        m_bNotifyFlag = false;
       }
     }
   }
 }
 
 void CFX_ListCtrl::SelectItems() {
   for (int32_t i = 0, sz = m_aSelItems.GetCount(); i < sz; i++) {
     int32_t nItemIndex = m_aSelItems.GetItemIndex(i);
     int32_t nState = m_aSelItems.GetState(i);
 
     switch (nState) {
       case 1:
-        SetMultipleSelect(nItemIndex, TRUE);
+        SetMultipleSelect(nItemIndex, true);
         break;
       case -1:
-        SetMultipleSelect(nItemIndex, FALSE);
+        SetMultipleSelect(nItemIndex, false);
         break;
     }
   }
 
   m_aSelItems.Done();
 }
 
 void CFX_ListCtrl::Select(int32_t nItemIndex) {
   if (!IsValid(nItemIndex))
     return;
 
   if (IsMultipleSel()) {
     m_aSelItems.Add(nItemIndex);
     SelectItems();
   } else {
     SetSingleSelect(nItemIndex);
   }
 }
 
-FX_BOOL CFX_ListCtrl::IsItemVisible(int32_t nItemIndex) const {
+bool CFX_ListCtrl::IsItemVisible(int32_t nItemIndex) const {
   CFX_FloatRect rcPlate = GetPlateRect();
   CFX_FloatRect rcItem = GetItemRect(nItemIndex);
 
   return rcItem.bottom >= rcPlate.bottom && rcItem.top <= rcPlate.top;
 }
 
 void CFX_ListCtrl::ScrollToListItem(int32_t nItemIndex) {
   if (!IsValid(nItemIndex))
     return;
 
@@ skipping 11 matching lines @@
     }
   }
 }
 
 void CFX_ListCtrl::SetScrollInfo() {
   if (m_pNotify) {
     CFX_FloatRect rcPlate = GetPlateRect();
     CFX_FloatRect rcContent = GetContentRectInternal();
 
     if (!m_bNotifyFlag) {
-      m_bNotifyFlag = TRUE;
+      m_bNotifyFlag = true;
       m_pNotify->IOnSetScrollInfoY(rcPlate.bottom, rcPlate.top,
                                    rcContent.bottom, rcContent.top,
                                    GetFirstHeight(), rcPlate.Height());
-      m_bNotifyFlag = FALSE;
+      m_bNotifyFlag = false;
     }
   }
 }
 
 void CFX_ListCtrl::SetScrollPos(const CFX_FloatPoint& point) {
   SetScrollPosY(point.y);
 }
 
 void CFX_ListCtrl::SetScrollPosY(FX_FLOAT fy) {
   if (!IsFloatEqual(m_ptScrollPos.y, fy)) {
     CFX_FloatRect rcPlate = GetPlateRect();
     CFX_FloatRect rcContent = GetContentRectInternal();
 
     if (rcPlate.Height() > rcContent.Height()) {
       fy = rcPlate.top;
     } else {
       if (IsFloatSmaller(fy - rcPlate.Height(), rcContent.bottom)) {
         fy = rcContent.bottom + rcPlate.Height();
       } else if (IsFloatBigger(fy, rcContent.top)) {
         fy = rcContent.top;
       }
     }
 
     m_ptScrollPos.y = fy;
     InvalidateItem(-1);
 
     if (m_pNotify) {
       if (!m_bNotifyFlag) {
-        m_bNotifyFlag = TRUE;
+        m_bNotifyFlag = true;
         m_pNotify->IOnSetScrollPosY(fy);
-        m_bNotifyFlag = FALSE;
+        m_bNotifyFlag = false;
       }
     }
   }
 }
 
 CFX_FloatRect CFX_ListCtrl::GetContentRectInternal() const {
   return InnerToOuter(CFX_ListContainer::GetContentRect());
 }
 
 CFX_FloatRect CFX_ListCtrl::GetContentRect() const {
@@ skipping 44 matching lines @@
   InvalidateItem(-1);
 }
 
 void CFX_ListCtrl::Cancel() {
   m_aSelItems.DeselectAll();
 }
 
 int32_t CFX_ListCtrl::GetItemIndex(const CFX_FloatPoint& point) const {
   CFX_FloatPoint pt = OuterToInner(OutToIn(point));
 
-  FX_BOOL bFirst = TRUE;
-  FX_BOOL bLast = TRUE;
+  bool bFirst = true;
+  bool bLast = true;
 
   for (int32_t i = 0, sz = m_aListItems.GetSize(); i < sz; i++) {
     if (CFX_ListItem* pListItem = m_aListItems.GetAt(i)) {
       CLST_Rect rcListItem = pListItem->GetRect();
 
       if (IsFloatBigger(pt.y, rcListItem.top)) {
-        bFirst = FALSE;
+        bFirst = false;
       }
 
       if (IsFloatSmaller(pt.y, rcListItem.bottom)) {
-        bLast = FALSE;
+        bLast = false;
       }
 
       if (pt.y >= rcListItem.top && pt.y < rcListItem.bottom) {
         return i;
       }
     }
   }
 
   if (bFirst)
     return 0;
@@ skipping 89 matching lines @@
 
     if (CFX_ListItem* pListItem = m_aListItems.GetAt(nCircleIndex)) {
       if (Toupper(pListItem->GetFirstChar()) == Toupper(nChar))
         return nCircleIndex;
     }
   }
 
   return nCircleIndex;
 }
 
-FX_BOOL CFX_ListCtrl::IsItemSelected(int32_t nIndex) const {
+bool CFX_ListCtrl::IsItemSelected(int32_t nIndex) const {
   if (CFX_ListItem* pListItem = m_aListItems.GetAt(nIndex))
     return pListItem->IsSelected();
-  return FALSE;
+  return false;
 }
 
-void CFX_ListCtrl::SetItemSelect(int32_t nItemIndex, FX_BOOL bSelected) {
+void CFX_ListCtrl::SetItemSelect(int32_t nItemIndex, bool bSelected) {
   if (CFX_ListItem* pListItem = m_aListItems.GetAt(nItemIndex)) {
     pListItem->SetSelect(bSelected);
   }
 }
 
-void CFX_ListCtrl::SetMultipleSel(FX_BOOL bMultiple) {
+void CFX_ListCtrl::SetMultipleSel(bool bMultiple) {
   m_bMultiple = bMultiple;
 }
 
-FX_BOOL CFX_ListCtrl::IsMultipleSel() const {
+bool CFX_ListCtrl::IsMultipleSel() const {
   return m_bMultiple;
 }
 
-FX_BOOL CFX_ListCtrl::IsValid(int32_t nItemIndex) const {
+bool CFX_ListCtrl::IsValid(int32_t nItemIndex) const {
   return nItemIndex >= 0 && nItemIndex < m_aListItems.GetSize();
 }
 
 CFX_WideString CFX_ListCtrl::GetItemText(int32_t nIndex) const {
   if (CFX_ListItem* pListItem = m_aListItems.GetAt(nIndex)) {
     return pListItem->GetText();
   }
 
   return L"";
 }