FX_BOOL considered harmful.

fpdfsdk/src/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 "../../include/fxedit/fxet_stub.h"
 #include "../../include/fxedit/fxet_edit.h"
 #include "../../include/fxedit/fxet_list.h"
 
 /* ------------------------------- CFX_ListItem ---------------------------------- */
 
 CFX_ListItem::CFX_ListItem() : m_pEdit(NULL),
-        m_bSelected(FALSE),
-        m_bCaret(FALSE),
+        m_bSelected(false),
+        m_bCaret(false),
         m_rcListItem(0.0f,0.0f,0.0f,0.0f)
 {
         m_pEdit = IFX_Edit::NewEdit();
         ASSERT(m_pEdit != NULL);
 
         m_pEdit->SetAlignmentV(1);
         m_pEdit->Initialize();
 }
 
 CFX_ListItem::~CFX_ListItem()
@@ skipping 23 matching lines @@
 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;
 }
 
-FX_BOOL CFX_ListItem::IsCaret() const
+bool CFX_ListItem::IsCaret() const
 {
         return m_bCaret;
 }
 
-void CFX_ListItem::SetCaret(FX_BOOL bCaret)
+void CFX_ListItem::SetCaret(bool bCaret)
 {
         m_bCaret = bCaret;
 }
 
 void CFX_ListItem::SetText(const FX_WCHAR* text)
 {
         if (m_pEdit)
                 m_pEdit->SetText(text);
 }
 
@@ skipping 27 matching lines @@
 CFX_WideString CFX_ListItem::GetText() const
 {
         if (m_pEdit)
                 return m_pEdit->GetText();
 
         return L"";
 }
 
 /* ------------------------------------ CFX_List --------------------------------- */
 
-CFX_List::CFX_List() : m_fFontSize(0.0f), m_pFontMap(NULL), m_bMultiple(FALSE)
+CFX_List::CFX_List() : m_fFontSize(0.0f), m_pFontMap(NULL), m_bMultiple(false)
 {
 }
 
 CFX_List::~CFX_List()
 {
         Empty();
 }
 
 void CFX_List::Empty()
 {
@@ skipping 71 matching lines @@
 
 FX_FLOAT CFX_List::GetFontSize() const
 {
         return m_fFontSize;
 }
 
 int32_t CFX_List::GetItemIndex(const CPDF_Point & point) const
 {
         CPDF_Point pt = OuterToInner(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 (FX_EDIT_IsFloatBigger(pt.y, rcListItem.top))
                         {
-                                bFirst = FALSE;
+                                bFirst = false;
                         }
 
                         if (FX_EDIT_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 70 matching lines @@
         {
                 CPDF_Rect rcItem = pListItem->GetRect();
                 rcItem.left = 0.0f;
                 rcItem.right = GetPlateRect().Width();
                 return InnerToOuter(rcItem);
         }
 
         return CPDF_Rect();
 }
 
-FX_BOOL CFX_List::IsItemSelected(int32_t nIndex) const
+bool CFX_List::IsItemSelected(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 return pListItem->IsSelected();
         }
 
-        return FALSE;
+        return false;
 }
 
-void CFX_List::SetItemSelect(int32_t nItemIndex, FX_BOOL bSelected)
+void CFX_List::SetItemSelect(int32_t nItemIndex, bool bSelected)
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nItemIndex))
         {
                 pListItem->SetSelect(bSelected);
         }
 }
 
-void CFX_List::SetItemCaret(int32_t nItemIndex, FX_BOOL bCaret)
+void CFX_List::SetItemCaret(int32_t nItemIndex, bool bCaret)
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nItemIndex))
         {
                 pListItem->SetCaret(bCaret);
         }
 }
 
-void CFX_List::SetMultipleSel(FX_BOOL bMultiple)
+void CFX_List::SetMultipleSel(bool bMultiple)
 {
         m_bMultiple = bMultiple;
 }
 
-FX_BOOL CFX_List::IsMultipleSel() const
+bool CFX_List::IsMultipleSel() const
 {
         return m_bMultiple;
 }
 
-FX_BOOL CFX_List::IsValid(int32_t nItemIndex) const
+bool CFX_List::IsValid(int32_t nItemIndex) const
 {
         return nItemIndex >= 0 && nItemIndex < m_aListItems.GetSize();
 }
 
 CFX_WideString CFX_List::GetItemText(int32_t nIndex) const
 {
         if (CFX_ListItem * pListItem = m_aListItems.GetAt(nIndex))
         {
                 return pListItem->GetText();
         }
@@ skipping 71 matching lines @@
                 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
@@ skipping 40 matching lines @@
                         {
                                 pItem->nState = 0;
                         }
                 }
         }
 }
 
 /* ------------------------------------ CFX_ListCtrl --------------------------------- */
 
 CFX_ListCtrl::CFX_ListCtrl() : m_pNotify(NULL),
-        m_bNotifyFlag(FALSE),
+        m_bNotifyFlag(false),
         m_ptScrollPos(0.0f,0.0f),
         m_nSelItem(-1),
         m_nFootIndex(-1),
-        m_bCtrlSel(FALSE),
+        m_bCtrlSel(false),
         m_nCaretIndex(-1)
 {
 }
 
 CFX_ListCtrl::~CFX_ListCtrl()
 {
 }
 
 void CFX_ListCtrl::SetNotify(IFX_List_Notify * pNotify)
 {
@@ skipping 25 matching lines @@
 }
 
 CPDF_Rect CFX_ListCtrl::OutToIn(const CPDF_Rect & rect) const
 {
         CPDF_Point ptLeftBottom = OutToIn(CPDF_Point(rect.left,rect.bottom));
         CPDF_Point ptRightTop = OutToIn(CPDF_Point(rect.right,rect.top));
 
         return CPDF_Rect(ptLeftBottom.x,ptLeftBottom.y,ptRightTop.x,ptRightTop.y);
 }
 
-void CFX_ListCtrl::OnMouseDown(const CPDF_Point & point,FX_BOOL bShift,FX_BOOL bCtrl)
+void CFX_ListCtrl::OnMouseDown(const CPDF_Point & point,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();
                 }
@@ skipping 10 matching lines @@
         }
         else
         {
                 SetSingleSelect(nHitIndex);
         }
 
         if (!IsItemVisible(nHitIndex))
                 ScrollToListItem(nHitIndex);
 }
 
-void CFX_ListCtrl::OnMouseMove(const CPDF_Point & point,FX_BOOL bShift,FX_BOOL bCtrl)
+void CFX_ListCtrl::OnMouseMove(const CPDF_Point & point,bool bShift,bool bCtrl)
 {
         int32_t nHitIndex = GetItemIndex(point);
 
         if (IsMultipleSel())
         {
                 if (bCtrl)
                 {
                         if (m_bCtrlSel)
                                 m_aSelItems.Add(m_nFootIndex,nHitIndex);
                         else
@@ skipping 12 matching lines @@
         }
         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)
                         {
@@ skipping 14 matching lines @@
         }
         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(FX_WORD nChar,FX_BOOL bShift,FX_BOOL bCtrl)
+bool    CFX_ListCtrl::OnChar(FX_WORD 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;
 }
 
 /* -------- inner methods ------- */
 
 void CFX_ListCtrl::SetPlateRect(const CPDF_Rect & rect)
 {
         CFX_ListContainer::SetPlateRect(rect);
         m_ptScrollPos.x = rect.left;
         SetScrollPos(CPDF_Point(rect.left,rect.top));
         ReArrange(0);
         InvalidateItem(-1);
 }
 
 CPDF_Rect CFX_ListCtrl::GetItemRect(int32_t nIndex) const
 {
         return InToOut(CFX_List::GetItemRect(nIndex));
 }
 
 void CFX_ListCtrl::AddString(const FX_WCHAR* string)
 {
         AddItem(string);
         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;
 
-                        SetItemCaret(nOldIndex, FALSE);
-                        SetItemCaret(nItemIndex,TRUE);
+                        SetItemCaret(nOldIndex, false);
+                        SetItemCaret(nItemIndex,true);
 
                         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;
                                 CPDF_Rect rcRefresh = GetPlateRect();
                                 m_pNotify->IOnInvalidateRect(&rcRefresh);
-                                m_bNotifyFlag = FALSE;
+                                m_bNotifyFlag = false;
                         }
                 }
                 else
                 {
                         if (!m_bNotifyFlag)
                         {
-                                m_bNotifyFlag = TRUE;
+                                m_bNotifyFlag = true;
                                 CPDF_Rect 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
 {
         CPDF_Rect rcPlate = GetPlateRect();
         CPDF_Rect rcItem = GetItemRect(nItemIndex);
 
         return rcItem.bottom >= rcPlate.bottom && rcItem.top <= rcPlate.top;
 }
 
 void CFX_ListCtrl::ScrollToListItem(int32_t nItemIndex)
 {
         if (!IsValid(nItemIndex)) return;
@@ skipping 20 matching lines @@
 
 void CFX_ListCtrl::SetScrollInfo()
 {
         if (m_pNotify)
         {
                 CPDF_Rect rcPlate = GetPlateRect();
                 CPDF_Rect rcContent = CFX_List::GetContentRect();
 
                 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 CPDF_Point & point)
 {
         SetScrollPosY(point.y);
 }
 
 void CFX_ListCtrl::SetScrollPosY(FX_FLOAT fy)
@@ skipping 19 matching lines @@
                         }
                 }
 
                 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;
                         }
                 }
         }
 }
 
 CPDF_Rect CFX_ListCtrl::GetContentRect() const
 {
         return InToOut(CFX_List::GetContentRect());
 }
 
@@ skipping 39 matching lines @@
         return CFX_List::GetItemIndex(OutToIn(point));
 }
 
 CFX_WideString CFX_ListCtrl::GetText() const
 {
     if (IsMultipleSel())
         return GetItemText(m_nCaretIndex);
     return GetItemText(m_nSelItem);
 }