Remove FX_BOOL from xfa.

xfa/fwl/core/ifwl_listbox.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fwl/core/ifwl_listbox.h"
 
 #include "third_party/base/ptr_util.h"
 #include "xfa/fde/tto/fde_textout.h"
@@ skipping 11 matching lines @@
 }  // namespace
 
 IFWL_ListBox::IFWL_ListBox(const IFWL_App* app,
                            const CFWL_WidgetImpProperties& properties,
                            IFWL_Widget* pOuter)
     : IFWL_Widget(app, properties, pOuter),
       m_dwTTOStyles(0),
       m_iTTOAligns(0),
       m_hAnchor(nullptr),
       m_fScorllBarWidth(0),
-      m_bLButtonDown(FALSE),
+      m_bLButtonDown(false),
       m_pScrollBarTP(nullptr) {
   m_rtClient.Reset();
   m_rtConent.Reset();
   m_rtStatic.Reset();
 }
 
 IFWL_ListBox::~IFWL_ListBox() {}
 
 FWL_Type IFWL_ListBox::GetClassID() const {
   return FWL_Type::ListBox;
 }
 
-FWL_Error IFWL_ListBox::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
+FWL_Error IFWL_ListBox::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
     rect.Set(0, 0, 0, 0);
     if (!m_pProperties->m_pThemeProvider) {
       m_pProperties->m_pThemeProvider = GetAvailableTheme();
     }
-    CFX_SizeF fs = CalcSize(TRUE);
+    CFX_SizeF fs = CalcSize(true);
     rect.Set(0, 0, fs.x, fs.y);
-    IFWL_Widget::GetWidgetRect(rect, TRUE);
+    IFWL_Widget::GetWidgetRect(rect, true);
   } else {
     rect = m_pProperties->m_rtWidget;
   }
   return FWL_Error::Succeeded;
 }
 
 FWL_Error IFWL_ListBox::Update() {
   if (IsLocked()) {
     return FWL_Error::Indefinite;
   }
@@ skipping 16 matching lines @@
   if (m_pProperties->m_dwStyleExes & FWL_WGTSTYLE_RTLReading) {
     m_dwTTOStyles |= FDE_TTOSTYLE_RTL;
   }
   m_dwTTOStyles |= FDE_TTOSTYLE_SingleLine;
   m_fScorllBarWidth = GetScrollWidth();
   CalcSize();
   return FWL_Error::Succeeded;
 }
 
 FWL_WidgetHit IFWL_ListBox::HitTest(FX_FLOAT fx, FX_FLOAT fy) {
-  if (IsShowScrollBar(FALSE)) {
+  if (IsShowScrollBar(false)) {
     CFX_RectF rect;
     m_pHorzScrollBar->GetWidgetRect(rect);
     if (rect.Contains(fx, fy))
       return FWL_WidgetHit::HScrollBar;
   }
-  if (IsShowScrollBar(TRUE)) {
+  if (IsShowScrollBar(true)) {
     CFX_RectF rect;
     m_pVertScrollBar->GetWidgetRect(rect);
     if (rect.Contains(fx, fy))
       return FWL_WidgetHit::VScrollBar;
   }
   if (m_rtClient.Contains(fx, fy))
     return FWL_WidgetHit::Client;
   return FWL_WidgetHit::Unknown;
 }
 
 FWL_Error IFWL_ListBox::DrawWidget(CFX_Graphics* pGraphics,
                                    const CFX_Matrix* pMatrix) {
   if (!pGraphics)
     return FWL_Error::Indefinite;
   if (!m_pProperties->m_pThemeProvider)
     return FWL_Error::Indefinite;
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   pGraphics->SaveGraphState();
   if (HasBorder()) {
     DrawBorder(pGraphics, CFWL_Part::Border, pTheme, pMatrix);
   }
   if (HasEdge()) {
     DrawEdge(pGraphics, CFWL_Part::Edge, pTheme, pMatrix);
   }
   CFX_RectF rtClip(m_rtConent);
-  if (IsShowScrollBar(FALSE)) {
+  if (IsShowScrollBar(false)) {
     rtClip.height -= m_fScorllBarWidth;
   }
-  if (IsShowScrollBar(TRUE)) {
+  if (IsShowScrollBar(true)) {
     rtClip.width -= m_fScorllBarWidth;
   }
   if (pMatrix) {
     pMatrix->TransformRect(rtClip);
   }
   pGraphics->SetClipRect(rtClip);
   if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_NoBackground) == 0) {
     DrawBkground(pGraphics, pTheme, pMatrix);
   }
   DrawItems(pGraphics, pTheme, pMatrix);
@@ skipping 68 matching lines @@
       if (index == nIndex) {
         return i;
       } else {
         index++;
       }
     }
   }
   return -1;
 }
 
-FWL_Error IFWL_ListBox::SetSelItem(IFWL_ListItem* pItem, FX_BOOL bSelect) {
+FWL_Error IFWL_ListBox::SetSelItem(IFWL_ListItem* pItem, bool bSelect) {
   if (!m_pProperties->m_pDataProvider)
     return FWL_Error::Indefinite;
   if (!pItem) {
     if (bSelect) {
       SelectAll();
     } else {
       ClearSelection();
       SetFocusItem(nullptr);
     }
     return FWL_Error::Indefinite;
@@ skipping 11 matching lines @@
   if (!m_pProperties->m_pDataProvider)
     return FWL_Error::Indefinite;
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   if (!pItem)
     return FWL_Error::Indefinite;
   pData->GetItemText(this, pItem, wsText);
   return FWL_Error::Succeeded;
 }
 
-FWL_Error IFWL_ListBox::GetScrollPos(FX_FLOAT& fPos, FX_BOOL bVert) {
-  if ((bVert && IsShowScrollBar(TRUE)) || (!bVert && IsShowScrollBar(FALSE))) {
+FWL_Error IFWL_ListBox::GetScrollPos(FX_FLOAT& fPos, bool bVert) {
+  if ((bVert && IsShowScrollBar(true)) || (!bVert && IsShowScrollBar(false))) {
     IFWL_ScrollBar* pScrollBar =
         bVert ? m_pVertScrollBar.get() : m_pHorzScrollBar.get();
     fPos = pScrollBar->GetPos();
     return FWL_Error::Succeeded;
   }
   return FWL_Error::Indefinite;
 }
 
 IFWL_ListItem* IFWL_ListBox::GetItem(IFWL_ListItem* pItem, uint32_t dwKeyCode) {
   IFWL_ListItem* hRet = nullptr;
@@ skipping 20 matching lines @@
       hRet = pData->GetItem(this, iDstItem);
       break;
     }
     default: {}
   }
   return hRet;
 }
 
 void IFWL_ListBox::SetSelection(IFWL_ListItem* hStart,
                                 IFWL_ListItem* hEnd,
-                                FX_BOOL bSelected) {
+                                bool bSelected) {
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   int32_t iStart = pData->GetItemIndex(this, hStart);
   int32_t iEnd = pData->GetItemIndex(this, hEnd);
   if (iStart > iEnd) {
     int32_t iTemp = iStart;
     iStart = iEnd;
     iEnd = iTemp;
   }
   if (bSelected) {
     int32_t iCount = pData->CountItems(this);
     for (int32_t i = 0; i < iCount; i++) {
       IFWL_ListItem* pItem = pData->GetItem(this, i);
-      SetSelectionDirect(pItem, FALSE);
+      SetSelectionDirect(pItem, false);
     }
   }
   for (; iStart <= iEnd; iStart++) {
     IFWL_ListItem* pItem = pData->GetItem(this, iStart);
     SetSelectionDirect(pItem, bSelected);
   }
 }
 
-void IFWL_ListBox::SetSelectionDirect(IFWL_ListItem* pItem, FX_BOOL bSelect) {
+void IFWL_ListBox::SetSelectionDirect(IFWL_ListItem* pItem, bool bSelect) {
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   uint32_t dwOldStyle = pData->GetItemStyles(this, pItem);
   bSelect ? dwOldStyle |= FWL_ITEMSTATE_LTB_Selected
           : dwOldStyle &= ~FWL_ITEMSTATE_LTB_Selected;
   pData->SetItemStyles(this, pItem, dwOldStyle);
 }
 
-FX_BOOL IFWL_ListBox::IsItemSelected(IFWL_ListItem* pItem) {
+bool IFWL_ListBox::IsItemSelected(IFWL_ListItem* pItem) {
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   uint32_t dwState = pData->GetItemStyles(this, pItem);
   return (dwState & FWL_ITEMSTATE_LTB_Selected) != 0;
 }
 
 void IFWL_ListBox::ClearSelection() {
-  FX_BOOL bMulti =
-      m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
+  bool bMulti = m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     IFWL_ListItem* pItem = pData->GetItem(this, i);
     uint32_t dwState = pData->GetItemStyles(this, pItem);
     if (!(dwState & FWL_ITEMSTATE_LTB_Selected))
       continue;
-    SetSelectionDirect(pItem, FALSE);
+    SetSelectionDirect(pItem, false);
     if (!bMulti)
       return;
   }
 }
 
 void IFWL_ListBox::SelectAll() {
-  FX_BOOL bMulti =
-      m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
+  bool bMulti = m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
   if (!bMulti) {
     return;
   }
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   if (iCount > 0) {
     IFWL_ListItem* pItemStart = pData->GetItem(this, 0);
     IFWL_ListItem* pItemEnd = pData->GetItem(this, iCount - 1);
-    SetSelection(pItemStart, pItemEnd, FALSE);
+    SetSelection(pItemStart, pItemEnd, false);
   }
 }
 
 IFWL_ListItem* IFWL_ListBox::GetFocusedItem() {
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     IFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
@@ skipping 44 matching lines @@
     CFX_RectF rtItem;
     pData->GetItemRect(this, pItem, rtItem);
     rtItem.Offset(-fPosX, -fPosY);
     if (rtItem.Contains(fx, fy)) {
       return pItem;
     }
   }
   return nullptr;
 }
 
-FX_BOOL IFWL_ListBox::GetItemCheckRect(IFWL_ListItem* pItem,
-                                       CFX_RectF& rtCheck) {
+bool IFWL_ListBox::GetItemCheckRect(IFWL_ListItem* pItem, CFX_RectF& rtCheck) {
   if (!m_pProperties->m_pDataProvider)
-    return FALSE;
+    return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check)) {
-    return FALSE;
+    return false;
   }
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   pData->GetItemCheckRect(this, pItem, rtCheck);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_ListBox::GetItemChecked(IFWL_ListItem* pItem) {
+bool IFWL_ListBox::GetItemChecked(IFWL_ListItem* pItem) {
   if (!m_pProperties->m_pDataProvider)
-    return FALSE;
+    return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check)) {
-    return FALSE;
+    return false;
   }
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   return !!(pData->GetItemCheckState(this, pItem) & FWL_ITEMSTATE_LTB_Checked);
 }
 
-FX_BOOL IFWL_ListBox::SetItemChecked(IFWL_ListItem* pItem, FX_BOOL bChecked) {
+bool IFWL_ListBox::SetItemChecked(IFWL_ListItem* pItem, bool bChecked) {
   if (!m_pProperties->m_pDataProvider)
-    return FALSE;
+    return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check)) {
-    return FALSE;
+    return false;
   }
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   pData->SetItemCheckState(this, pItem,
                            bChecked ? FWL_ITEMSTATE_LTB_Checked : 0);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_ListBox::ScrollToVisible(IFWL_ListItem* pItem) {
+bool IFWL_ListBox::ScrollToVisible(IFWL_ListItem* pItem) {
   if (!m_pVertScrollBar)
-    return FALSE;
+    return false;
   CFX_RectF rtItem;
   IFWL_ListBoxDP* pData =
       static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
   pData->GetItemRect(this, pItem, rtItem);
-  FX_BOOL bScroll = FALSE;
+  bool bScroll = false;
   FX_FLOAT fPosY = m_pVertScrollBar->GetPos();
   rtItem.Offset(0, -fPosY + m_rtConent.top);
   if (rtItem.top < m_rtConent.top) {
     fPosY += rtItem.top - m_rtConent.top;
-    bScroll = TRUE;
+    bScroll = true;
   } else if (rtItem.bottom() > m_rtConent.bottom()) {
     fPosY += rtItem.bottom() - m_rtConent.bottom();
-    bScroll = TRUE;
+    bScroll = true;
   }
   if (!bScroll) {
-    return FALSE;
+    return false;
   }
   m_pVertScrollBar->SetPos(fPosY);
   m_pVertScrollBar->SetTrackPos(fPosY);
   Repaint(&m_rtClient);
-  return TRUE;
+  return true;
 }
 
 void IFWL_ListBox::DrawBkground(CFX_Graphics* pGraphics,
                                 IFWL_ThemeProvider* pTheme,
                                 const CFX_Matrix* pMatrix) {
   if (!pGraphics)
     return;
   if (!pTheme)
     return;
   CFWL_ThemeBackground param;
   param.m_pWidget = this;
   param.m_iPart = CFWL_Part::Background;
   param.m_dwStates = 0;
   param.m_pGraphics = pGraphics;
   param.m_matrix.Concat(*pMatrix);
   param.m_rtPart = m_rtClient;
-  if (IsShowScrollBar(FALSE) && IsShowScrollBar(TRUE)) {
+  if (IsShowScrollBar(false) && IsShowScrollBar(true)) {
     param.m_pData = &m_rtStatic;
   }
   if (!IsEnabled()) {
     param.m_dwStates = CFWL_PartState_Disabled;
   }
   pTheme->DrawBackground(&param);
 }
 
 void IFWL_ListBox::DrawItems(CFX_Graphics* pGraphics,
                              IFWL_ThemeProvider* pTheme,
@@ skipping 143 matching lines @@
     textParam.m_matrix.Concat(*pMatrix);
     textParam.m_rtPart = rtText;
     textParam.m_wsText = wsText;
     textParam.m_dwTTOStyles = m_dwTTOStyles;
     textParam.m_iTTOAlign = m_iTTOAligns;
     textParam.m_bMaximize = true;
     pTheme->DrawText(&textParam);
   }
 }
 
-CFX_SizeF IFWL_ListBox::CalcSize(FX_BOOL bAutoSize) {
+CFX_SizeF IFWL_ListBox::CalcSize(bool bAutoSize) {
   CFX_SizeF fs;
   if (!m_pProperties->m_pThemeProvider)
     return fs;
 
   GetClientRect(m_rtClient);
   m_rtConent = m_rtClient;
   CFX_RectF rtUIMargin;
   rtUIMargin.Set(0, 0, 0, 0);
   if (!m_pOuter) {
     CFX_RectF* pUIMargin = static_cast<CFX_RectF*>(
@@ skipping 42 matching lines @@
     for (int32_t i = 0; i < iCount; i++) {
       IFWL_ListItem* htem = pData->GetItem(this, i);
       GetItemSize(fs, htem, fWidth, m_fItemHeight, bAutoSize);
     }
   }
   if (bAutoSize) {
     return fs;
   }
   FX_FLOAT iWidth = m_rtClient.width - rtUIMargin.left - rtUIMargin.width;
   FX_FLOAT iHeight = m_rtClient.height;
-  FX_BOOL bShowVertScr =
+  bool bShowVertScr =
       (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarAlaways) &&
       (m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll);
-  FX_BOOL bShowHorzScr =
+  bool bShowHorzScr =
       (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarAlaways) &&
       (m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll);
   if (!bShowVertScr && m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll &&
       (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn) == 0) {
     bShowVertScr = (fs.y > iHeight);
   }
   if (!bShowHorzScr && m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll) {
     bShowHorzScr = (fs.x > iWidth);
   }
   CFX_SizeF szRange;
@@ skipping 20 matching lines @@
       fPos = 0;
     }
     if (fPos > szRange.y) {
       fPos = szRange.y;
     }
     m_pVertScrollBar->SetPos(fPos);
     m_pVertScrollBar->SetTrackPos(fPos);
     if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarFocus) ==
             0 ||
         (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)) {
-      m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, FALSE);
+      m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, false);
     }
     m_pVertScrollBar->Update();
   } else if (m_pVertScrollBar) {
     m_pVertScrollBar->SetPos(0);
     m_pVertScrollBar->SetTrackPos(0);
-    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, TRUE);
+    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
   }
   if (bShowHorzScr) {
     if (!m_pHorzScrollBar) {
-      InitScrollBar(FALSE);
+      InitScrollBar(false);
     }
     CFX_RectF rtScrollBar;
     rtScrollBar.Set(m_rtClient.left, m_rtClient.bottom() - m_fScorllBarWidth,
                     m_rtClient.width, m_fScorllBarWidth);
     if (bShowVertScr) {
       rtScrollBar.width -= m_fScorllBarWidth;
     }
     m_pHorzScrollBar->SetWidgetRect(rtScrollBar);
     szRange.x = 0, szRange.y = fs.x - rtScrollBar.width;
     m_pHorzScrollBar->SetRange(szRange.x, szRange.y);
     m_pHorzScrollBar->SetPageSize(fWidth * 9 / 10);
     m_pHorzScrollBar->SetStepSize(fWidth / 10);
     FX_FLOAT fPos = m_pHorzScrollBar->GetPos();
     if (fPos < 0) {
       fPos = 0;
     }
     if (fPos > szRange.y) {
       fPos = szRange.y;
     }
     m_pHorzScrollBar->SetPos(fPos);
     m_pHorzScrollBar->SetTrackPos(fPos);
     if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarFocus) ==
             0 ||
         (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)) {
-      m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, FALSE);
+      m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, false);
     }
     m_pHorzScrollBar->Update();
   } else if (m_pHorzScrollBar) {
     m_pHorzScrollBar->SetPos(0);
     m_pHorzScrollBar->SetTrackPos(0);
-    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, TRUE);
+    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
   }
   if (bShowVertScr && bShowHorzScr) {
     m_rtStatic.Set(m_rtClient.right() - m_fScorllBarWidth,
                    m_rtClient.bottom() - m_fScorllBarWidth, m_fScorllBarWidth,
                    m_fScorllBarWidth);
   }
   return fs;
 }
 
 void IFWL_ListBox::GetItemSize(CFX_SizeF& size,
                                IFWL_ListItem* pItem,
                                FX_FLOAT fWidth,
                                FX_FLOAT fItemHeight,
-                               FX_BOOL bAutoSize) {
+                               bool bAutoSize) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn) {
   } else {
     if (!bAutoSize) {
       CFX_RectF rtItem;
       rtItem.Set(0, size.y, fWidth, fItemHeight);
       IFWL_ListBoxDP* pData =
           static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
       pData->SetItemRect(this, pItem, rtItem);
     }
     size.x = fWidth;
@@ skipping 30 matching lines @@
 }
 
 FX_FLOAT IFWL_ListBox::GetItemHeigt() {
   FX_FLOAT* pfFont =
       static_cast<FX_FLOAT*>(GetThemeCapacity(CFWL_WidgetCapacity::FontSize));
   if (!pfFont)
     return 20;
   return *pfFont + 2 * kItemTextMargin;
 }
 
-void IFWL_ListBox::InitScrollBar(FX_BOOL bVert) {
+void IFWL_ListBox::InitScrollBar(bool bVert) {
   if ((bVert && m_pVertScrollBar) || (!bVert && m_pHorzScrollBar)) {
     return;
   }
   CFWL_WidgetImpProperties prop;
   prop.m_dwStyleExes = bVert ? FWL_STYLEEXT_SCB_Vert : FWL_STYLEEXT_SCB_Horz;
   prop.m_dwStates = FWL_WGTSTATE_Invisible;
   prop.m_pParent = this;
   prop.m_pThemeProvider = m_pScrollBarTP;
   (bVert ? &m_pVertScrollBar : &m_pHorzScrollBar)
       ->reset(new IFWL_ScrollBar(m_pOwnerApp, prop, this));
 }
 
-FX_BOOL IFWL_ListBox::IsShowScrollBar(FX_BOOL bVert) {
+bool IFWL_ListBox::IsShowScrollBar(bool bVert) {
   IFWL_ScrollBar* pScrollbar =
       bVert ? m_pVertScrollBar.get() : m_pHorzScrollBar.get();
   if (!pScrollbar || (pScrollbar->GetStates() & FWL_WGTSTATE_Invisible)) {
-    return FALSE;
+    return false;
   }
   return !(m_pProperties->m_dwStyleExes &
            FWL_STYLEEXT_LTB_ShowScrollBarFocus) ||
          (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused);
 }
 
 void IFWL_ListBox::ProcessSelChanged() {
   CFWL_EvtLtbSelChanged selEvent;
   selEvent.m_pSrcTarget = this;
   CFX_Int32Array arrSels;
@@ skipping 10 matching lines @@
 
 void IFWL_ListBox::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
     return;
   if (!IsEnabled())
     return;
 
   CFWL_MessageType dwMsgCode = pMessage->GetClassID();
   switch (dwMsgCode) {
     case CFWL_MessageType::SetFocus:
-      OnFocusChanged(pMessage, TRUE);
+      OnFocusChanged(pMessage, true);
       break;
     case CFWL_MessageType::KillFocus:
-      OnFocusChanged(pMessage, FALSE);
+      OnFocusChanged(pMessage, false);
       break;
     case CFWL_MessageType::Mouse: {
       CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage);
       switch (pMsg->m_dwCmd) {
         case FWL_MouseCommand::LeftButtonDown:
           OnLButtonDown(pMsg);
           break;
         case FWL_MouseCommand::LeftButtonUp:
           OnLButtonUp(pMsg);
           break;
@@ skipping 30 matching lines @@
     OnScroll(static_cast<IFWL_ScrollBar*>(pSrcTarget),
              pScrollEvent->m_iScrollCode, pScrollEvent->m_fPos);
   }
 }
 
 void IFWL_ListBox::OnDrawWidget(CFX_Graphics* pGraphics,
                                 const CFX_Matrix* pMatrix) {
   DrawWidget(pGraphics, pMatrix);
 }
 
-void IFWL_ListBox::OnFocusChanged(CFWL_Message* pMsg, FX_BOOL bSet) {
+void IFWL_ListBox::OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
   if (GetStylesEx() & FWL_STYLEEXT_LTB_ShowScrollBarFocus) {
     if (m_pVertScrollBar)
       m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, !bSet);
     if (m_pHorzScrollBar)
       m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, !bSet);
   }
   if (bSet)
     m_pProperties->m_dwStates |= (FWL_WGTSTATE_Focused);
   else
     m_pProperties->m_dwStates &= ~(FWL_WGTSTATE_Focused);
 
   Repaint(&m_rtClient);
 }
 
 void IFWL_ListBox::OnLButtonDown(CFWL_MsgMouse* pMsg) {
-  m_bLButtonDown = TRUE;
+  m_bLButtonDown = true;
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
-    SetFocus(TRUE);
+    SetFocus(true);
 
   IFWL_ListItem* pItem = GetItemAtPoint(pMsg->m_fx, pMsg->m_fy);
   if (!pItem)
     return;
 
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection) {
     if (pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl) {
-      FX_BOOL bSelected = IsItemSelected(pItem);
+      bool bSelected = IsItemSelected(pItem);
       SetSelectionDirect(pItem, !bSelected);
       m_hAnchor = pItem;
     } else if (pMsg->m_dwFlags & FWL_KEYFLAG_Shift) {
       if (m_hAnchor)
-        SetSelection(m_hAnchor, pItem, TRUE);
+        SetSelection(m_hAnchor, pItem, true);
       else
-        SetSelectionDirect(pItem, TRUE);
+        SetSelectionDirect(pItem, true);
     } else {
-      SetSelection(pItem, pItem, TRUE);
+      SetSelection(pItem, pItem, true);
       m_hAnchor = pItem;
     }
   } else {
-    SetSelection(pItem, pItem, TRUE);
+    SetSelection(pItem, pItem, true);
   }
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check) {
     IFWL_ListItem* hSelectedItem = GetItemAtPoint(pMsg->m_fx, pMsg->m_fy);
     CFX_RectF rtCheck;
     GetItemCheckRect(hSelectedItem, rtCheck);
-    FX_BOOL bChecked = GetItemChecked(pItem);
+    bool bChecked = GetItemChecked(pItem);
     if (rtCheck.Contains(pMsg->m_fx, pMsg->m_fy)) {
       SetItemChecked(pItem, !bChecked);
       Update();
     }
   }
   SetFocusItem(pItem);
   ScrollToVisible(pItem);
-  SetGrab(TRUE);
+  SetGrab(true);
   ProcessSelChanged();
   Repaint(&m_rtClient);
 }
 
 void IFWL_ListBox::OnLButtonUp(CFWL_MsgMouse* pMsg) {
   if (!m_bLButtonDown)
     return;
 
-  m_bLButtonDown = FALSE;
-  SetGrab(FALSE);
+  m_bLButtonDown = false;
+  SetGrab(false);
   DispatchSelChangedEv();
 }
 
 void IFWL_ListBox::OnMouseWheel(CFWL_MsgMouseWheel* pMsg) {
-  if (IsShowScrollBar(TRUE))
+  if (IsShowScrollBar(true))
     m_pVertScrollBar->GetDelegate()->OnProcessMessage(pMsg);
 }
 
 void IFWL_ListBox::OnKeyDown(CFWL_MsgKey* pMsg) {
   uint32_t dwKeyCode = pMsg->m_dwKeyCode;
   switch (dwKeyCode) {
     case FWL_VKEY_Tab:
     case FWL_VKEY_Up:
     case FWL_VKEY_Down:
     case FWL_VKEY_Home:
     case FWL_VKEY_End: {
       IFWL_ListItem* pItem = GetFocusedItem();
       pItem = GetItem(pItem, dwKeyCode);
       bool bShift = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Shift);
       bool bCtrl = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl);
       OnVK(pItem, bShift, bCtrl);
       DispatchSelChangedEv();
       ProcessSelChanged();
       break;
     }
     default:
       break;
   }
 }
 
-void IFWL_ListBox::OnVK(IFWL_ListItem* pItem, FX_BOOL bShift, FX_BOOL bCtrl) {
+void IFWL_ListBox::OnVK(IFWL_ListItem* pItem, bool bShift, bool bCtrl) {
   if (!pItem)
     return;
 
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection) {
     if (bCtrl) {
     } else if (bShift) {
       if (m_hAnchor)
-        SetSelection(m_hAnchor, pItem, TRUE);
+        SetSelection(m_hAnchor, pItem, true);
       else
-        SetSelectionDirect(pItem, TRUE);
+        SetSelectionDirect(pItem, true);
     } else {
-      SetSelection(pItem, pItem, TRUE);
+      SetSelection(pItem, pItem, true);
       m_hAnchor = pItem;
     }
   } else {
-    SetSelection(pItem, pItem, TRUE);
+    SetSelection(pItem, pItem, true);
   }
 
   SetFocusItem(pItem);
   ScrollToVisible(pItem);
 
   CFX_RectF rtInvalidate;
   rtInvalidate.Set(0, 0, m_pProperties->m_rtWidget.width,
                    m_pProperties->m_rtWidget.height);
   Repaint(&rtInvalidate);
 }
 
-FX_BOOL IFWL_ListBox::OnScroll(IFWL_ScrollBar* pScrollBar,
-                               uint32_t dwCode,
-                               FX_FLOAT fPos) {
+bool IFWL_ListBox::OnScroll(IFWL_ScrollBar* pScrollBar,
+                            uint32_t dwCode,
+                            FX_FLOAT fPos) {
   CFX_SizeF fs;
   pScrollBar->GetRange(fs.x, fs.y);
   FX_FLOAT iCurPos = pScrollBar->GetPos();
   FX_FLOAT fStep = pScrollBar->GetStepSize();
   switch (dwCode) {
     case FWL_SCBCODE_Min: {
       fPos = fs.x;
       break;
     }
     case FWL_SCBCODE_Max: {
@@ skipping 21 matching lines @@
     case FWL_SCBCODE_PageForward: {
       fPos += pScrollBar->GetPageSize();
       if (fPos > fs.y)
         fPos = fs.y;
       break;
     }
     case FWL_SCBCODE_Pos:
     case FWL_SCBCODE_TrackPos:
       break;
     case FWL_SCBCODE_EndScroll:
-      return FALSE;
+      return false;
   }
   if (iCurPos != fPos) {
     pScrollBar->SetPos(fPos);
     pScrollBar->SetTrackPos(fPos);
     Repaint(&m_rtClient);
   }
-  return TRUE;
+  return true;
 }
 
 void IFWL_ListBox::DispatchSelChangedEv() {
   CFWL_EvtLtbSelChanged ev;
   ev.m_pSrcTarget = this;
   DispatchEvent(&ev);
 }