Remove FX_BOOL from xfa.

xfa/fwl/core/ifwl_combobox.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_combobox.h"
 
 #include "third_party/base/ptr_util.h"
 #include "xfa/fde/cfde_txtedtengine.h"
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/cfwl_themebackground.h"
 #include "xfa/fwl/core/cfwl_themepart.h"
 #include "xfa/fwl/core/cfwl_themetext.h"
 #include "xfa/fwl/core/cfwl_widgetmgr.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_comboboxproxy.h"
 #include "xfa/fwl/core/ifwl_comboedit.h"
 #include "xfa/fwl/core/ifwl_combolist.h"
 #include "xfa/fwl/core/ifwl_formproxy.h"
 #include "xfa/fwl/core/ifwl_themeprovider.h"
 
 IFWL_ComboBox::IFWL_ComboBox(const IFWL_App* app,
                              const CFWL_WidgetImpProperties& properties)
     : IFWL_Widget(app, properties, nullptr),
       m_pComboBoxProxy(nullptr),
-      m_bLButtonDown(FALSE),
+      m_bLButtonDown(false),
       m_iCurSel(-1),
       m_iBtnState(CFWL_PartState_Normal),
       m_fComboFormHandler(0),
-      m_bNeedShowList(FALSE) {
+      m_bNeedShowList(false) {
   m_rtClient.Reset();
   m_rtBtn.Reset();
   m_rtHandler.Reset();
 
   if (m_pWidgetMgr->IsFormDisabled()) {
     DisForm_InitComboList();
     DisForm_InitComboEdit();
     return;
   }
 
@@ skipping 15 matching lines @@
 
   SetStates(m_pProperties->m_dwStates);
 }
 
 IFWL_ComboBox::~IFWL_ComboBox() {}
 
 FWL_Type IFWL_ComboBox::GetClassID() const {
   return FWL_Type::ComboBox;
 }
 
-FWL_Error IFWL_ComboBox::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
+FWL_Error IFWL_ComboBox::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
     rect.Reset();
-    FX_BOOL bIsDropDown = IsDropDownStyle();
+    bool bIsDropDown = IsDropDownStyle();
     if (bIsDropDown && m_pEdit) {
-      m_pEdit->GetWidgetRect(rect, TRUE);
+      m_pEdit->GetWidgetRect(rect, true);
     } else {
       rect.width = 100;
       rect.height = 16;
     }
     if (!m_pProperties->m_pThemeProvider) {
       ReSetTheme();
     }
     FX_FLOAT* pFWidth = static_cast<FX_FLOAT*>(
         GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
     if (!pFWidth)
       return FWL_Error::Indefinite;
     rect.Inflate(0, 0, *pFWidth, 0);
-    IFWL_Widget::GetWidgetRect(rect, TRUE);
+    IFWL_Widget::GetWidgetRect(rect, true);
   } else {
     rect = m_pProperties->m_rtWidget;
   }
   return FWL_Error::Succeeded;
 }
 
 FWL_Error IFWL_ComboBox::ModifyStylesEx(uint32_t dwStylesExAdded,
                                         uint32_t dwStylesExRemoved) {
   if (m_pWidgetMgr->IsFormDisabled()) {
     return DisForm_ModifyStylesEx(dwStylesExAdded, dwStylesExRemoved);
   }
   bool bAddDropDown = !!(dwStylesExAdded & FWL_STYLEEXT_CMB_DropDown);
   bool bRemoveDropDown = !!(dwStylesExRemoved & FWL_STYLEEXT_CMB_DropDown);
   if (bAddDropDown && !m_pEdit) {
     CFWL_WidgetImpProperties prop;
     m_pEdit.reset(new IFWL_ComboEdit(m_pOwnerApp, prop, nullptr));
     m_pEdit->SetOuter(this);
     m_pEdit->SetParent(this);
   } else if (bRemoveDropDown && m_pEdit) {
-    m_pEdit->SetStates(FWL_WGTSTATE_Invisible, TRUE);
+    m_pEdit->SetStates(FWL_WGTSTATE_Invisible, true);
   }
   return IFWL_Widget::ModifyStylesEx(dwStylesExAdded, dwStylesExRemoved);
 }
 
 FWL_Error IFWL_ComboBox::Update() {
   if (m_pWidgetMgr->IsFormDisabled()) {
     return DisForm_Update();
   }
   if (IsLocked()) {
     return FWL_Error::Indefinite;
   }
   ReSetTheme();
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bDropDown = IsDropDownStyle();
   if (bDropDown && m_pEdit) {
     ReSetEditAlignment();
   }
   if (!m_pProperties->m_pThemeProvider) {
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
   }
   Layout();
   CFWL_ThemePart part;
   part.m_pWidget = this;
   m_fComboFormHandler =
@@ skipping 12 matching lines @@
 FWL_Error IFWL_ComboBox::DrawWidget(CFX_Graphics* pGraphics,
                                     const CFX_Matrix* pMatrix) {
   if (m_pWidgetMgr->IsFormDisabled()) {
     return DisForm_DrawWidget(pGraphics, pMatrix);
   }
   if (!pGraphics)
     return FWL_Error::Indefinite;
   if (!m_pProperties->m_pThemeProvider)
     return FWL_Error::Indefinite;
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
-  FX_BOOL bIsDropDown = IsDropDownStyle();
+  bool bIsDropDown = IsDropDownStyle();
   if (HasBorder()) {
     DrawBorder(pGraphics, CFWL_Part::Border, pTheme, pMatrix);
   }
   if (HasEdge()) {
     DrawEdge(pGraphics, CFWL_Part::Edge, pTheme, pMatrix);
   }
   if (!bIsDropDown) {
     CFX_RectF rtTextBk(m_rtClient);
     rtTextBk.width -= m_rtBtn.width;
     CFWL_ThemeBackground param;
@@ skipping 71 matching lines @@
     m_pEdit->SetThemeProvider(pThemeProvider);
   return FWL_Error::Succeeded;
 }
 
 int32_t IFWL_ComboBox::GetCurSel() {
   return m_iCurSel;
 }
 
 FWL_Error IFWL_ComboBox::SetCurSel(int32_t iSel) {
   int32_t iCount = m_pListBox->CountItems();
-  FX_BOOL bClearSel = iSel < 0 || iSel >= iCount;
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bClearSel = iSel < 0 || iSel >= iCount;
+  bool bDropDown = IsDropDownStyle();
   if (bDropDown && m_pEdit) {
     if (bClearSel) {
       m_pEdit->SetText(CFX_WideString());
     } else {
       CFX_WideString wsText;
       IFWL_ComboBoxDP* pData =
           static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
       IFWL_ListItem* hItem = pData->GetItem(this, iSel);
       m_pListBox->GetItemText(hItem, wsText);
       m_pEdit->SetText(wsText);
     }
     m_pEdit->Update();
   }
   m_iCurSel = bClearSel ? -1 : iSel;
   return FWL_Error::Succeeded;
 }
 
-void IFWL_ComboBox::SetStates(uint32_t dwStates, FX_BOOL bSet) {
-  FX_BOOL bIsDropDown = IsDropDownStyle();
+void IFWL_ComboBox::SetStates(uint32_t dwStates, bool bSet) {
+  bool bIsDropDown = IsDropDownStyle();
   if (bIsDropDown && m_pEdit)
     m_pEdit->SetStates(dwStates, bSet);
   if (m_pListBox)
     m_pListBox->SetStates(dwStates, bSet);
   IFWL_Widget::SetStates(dwStates, bSet);
 }
 
 FWL_Error IFWL_ComboBox::SetEditText(const CFX_WideString& wsText) {
   if (!m_pEdit)
     return FWL_Error::Indefinite;
@@ skipping 46 matching lines @@
     return FWL_Error::Indefinite;
   return m_pEdit->SetLimit(nLimit);
 }
 
 FWL_Error IFWL_ComboBox::EditDoClipboard(int32_t iCmd) {
   if (!m_pEdit)
     return FWL_Error::Indefinite;
   return m_pEdit->DoClipboard(iCmd);
 }
 
-FX_BOOL IFWL_ComboBox::EditRedo(const IFDE_TxtEdtDoRecord* pRecord) {
+bool IFWL_ComboBox::EditRedo(const IFDE_TxtEdtDoRecord* pRecord) {
   return m_pEdit && m_pEdit->Redo(pRecord);
 }
 
-FX_BOOL IFWL_ComboBox::EditUndo(const IFDE_TxtEdtDoRecord* pRecord) {
+bool IFWL_ComboBox::EditUndo(const IFDE_TxtEdtDoRecord* pRecord) {
   return m_pEdit && m_pEdit->Undo(pRecord);
 }
 
 IFWL_ListBox* IFWL_ComboBox::GetListBoxt() {
   return m_pListBox.get();
 }
 
-FX_BOOL IFWL_ComboBox::AfterFocusShowDropList() {
+bool IFWL_ComboBox::AfterFocusShowDropList() {
   if (!m_bNeedShowList) {
-    return FALSE;
+    return false;
   }
   if (m_pEdit) {
     MatchEditText();
   }
-  ShowDropList(TRUE);
-  m_bNeedShowList = FALSE;
-  return TRUE;
+  ShowDropList(true);
+  m_bNeedShowList = false;
+  return true;
 }
 
-FWL_Error IFWL_ComboBox::OpenDropDownList(FX_BOOL bActivate) {
+FWL_Error IFWL_ComboBox::OpenDropDownList(bool bActivate) {
   ShowDropList(bActivate);
   return FWL_Error::Succeeded;
 }
 
-FX_BOOL IFWL_ComboBox::EditCanUndo() {
+bool IFWL_ComboBox::EditCanUndo() {
   return m_pEdit->CanUndo();
 }
 
-FX_BOOL IFWL_ComboBox::EditCanRedo() {
+bool IFWL_ComboBox::EditCanRedo() {
   return m_pEdit->CanRedo();
 }
 
-FX_BOOL IFWL_ComboBox::EditUndo() {
+bool IFWL_ComboBox::EditUndo() {
   return m_pEdit->Undo();
 }
 
-FX_BOOL IFWL_ComboBox::EditRedo() {
+bool IFWL_ComboBox::EditRedo() {
   return m_pEdit->Redo();
 }
 
-FX_BOOL IFWL_ComboBox::EditCanCopy() {
+bool IFWL_ComboBox::EditCanCopy() {
   return m_pEdit->CountSelRanges() > 0;
 }
 
-FX_BOOL IFWL_ComboBox::EditCanCut() {
+bool IFWL_ComboBox::EditCanCut() {
   if (m_pEdit->GetStylesEx() & FWL_STYLEEXT_EDT_ReadOnly) {
-    return FALSE;
+    return false;
   }
   return m_pEdit->CountSelRanges() > 0;
 }
 
-FX_BOOL IFWL_ComboBox::EditCanSelectAll() {
+bool IFWL_ComboBox::EditCanSelectAll() {
   return m_pEdit->GetTextLength() > 0;
 }
 
-FX_BOOL IFWL_ComboBox::EditCopy(CFX_WideString& wsCopy) {
+bool IFWL_ComboBox::EditCopy(CFX_WideString& wsCopy) {
   return m_pEdit->Copy(wsCopy);
 }
 
-FX_BOOL IFWL_ComboBox::EditCut(CFX_WideString& wsCut) {
+bool IFWL_ComboBox::EditCut(CFX_WideString& wsCut) {
   return m_pEdit->Cut(wsCut);
 }
 
-FX_BOOL IFWL_ComboBox::EditPaste(const CFX_WideString& wsPaste) {
+bool IFWL_ComboBox::EditPaste(const CFX_WideString& wsPaste) {
   return m_pEdit->Paste(wsPaste);
 }
 
-FX_BOOL IFWL_ComboBox::EditSelectAll() {
+bool IFWL_ComboBox::EditSelectAll() {
   return m_pEdit->AddSelRange(0) == FWL_Error::Succeeded;
 }
 
-FX_BOOL IFWL_ComboBox::EditDelete() {
+bool IFWL_ComboBox::EditDelete() {
   return m_pEdit->ClearText() == FWL_Error::Succeeded;
 }
 
-FX_BOOL IFWL_ComboBox::EditDeSelect() {
+bool IFWL_ComboBox::EditDeSelect() {
   return m_pEdit->ClearSelections() == FWL_Error::Succeeded;
 }
 
 FWL_Error IFWL_ComboBox::GetBBox(CFX_RectF& rect) {
   if (m_pWidgetMgr->IsFormDisabled()) {
     return DisForm_GetBBox(rect);
   }
   rect = m_pProperties->m_rtWidget;
   if (m_pListBox && IsDropListShowed()) {
     CFX_RectF rtList;
@@ skipping 23 matching lines @@
   param.m_iPart = CFWL_Part::StretchHandler;
   param.m_dwStates = CFWL_PartState_Normal;
   param.m_pWidget = this;
   if (pMatrix) {
     param.m_matrix.Concat(*pMatrix);
   }
   param.m_rtPart = m_rtHandler;
   m_pProperties->m_pThemeProvider->DrawBackground(&param);
 }
 
-void IFWL_ComboBox::ShowDropList(FX_BOOL bActivate) {
+void IFWL_ComboBox::ShowDropList(bool bActivate) {
   if (m_pWidgetMgr->IsFormDisabled())
     return DisForm_ShowDropList(bActivate);
 
-  FX_BOOL bDropList = IsDropListShowed();
+  bool bDropList = IsDropListShowed();
   if (bDropList == bActivate)
     return;
   if (!m_pComboBoxProxy)
     InitProxyForm();
 
   m_pComboBoxProxy->Reset();
   if (bActivate) {
     m_pListBox->ChangeSelected(m_iCurSel);
     ReSetListItemAlignment();
     uint32_t dwStyleAdd = m_pProperties->m_dwStyleExes &
                           (FWL_STYLEEXT_CMB_Sort | FWL_STYLEEXT_CMB_OwnerDraw);
     m_pListBox->ModifyStylesEx(dwStyleAdd, 0);
-    m_pListBox->GetWidgetRect(m_rtList, TRUE);
+    m_pListBox->GetWidgetRect(m_rtList, true);
     FX_FLOAT fHeight = GetListHeight();
     if (fHeight > 0) {
       if (m_rtList.height > GetListHeight()) {
         m_rtList.height = GetListHeight();
         m_pListBox->ModifyStyles(FWL_WGTSTYLE_VScroll, 0);
       }
     }
     CFX_RectF rtAnchor;
     rtAnchor.Set(0, 0, m_pProperties->m_rtWidget.width,
                  m_pProperties->m_rtWidget.height);
@@ skipping 20 matching lines @@
       }
     }
     m_pComboBoxProxy->SetWidgetRect(m_rtProxy);
     m_pComboBoxProxy->Update();
     m_pListBox->SetWidgetRect(m_rtList);
     m_pListBox->Update();
     CFWL_EvtCmbPreDropDown ev;
     ev.m_pSrcTarget = this;
     DispatchEvent(&ev);
     m_fItemHeight = m_pListBox->m_fItemHeight;
-    m_pListBox->SetFocus(TRUE);
+    m_pListBox->SetFocus(true);
     m_pComboBoxProxy->DoModal();
-    m_pListBox->SetFocus(FALSE);
+    m_pListBox->SetFocus(false);
   } else {
     m_pComboBoxProxy->EndDoModal();
     CFWL_EvtCmbCloseUp ev;
     ev.m_pSrcTarget = this;
     DispatchEvent(&ev);
-    m_bLButtonDown = FALSE;
-    m_pListBox->m_bNotifyOwner = TRUE;
-    SetFocus(TRUE);
+    m_bLButtonDown = false;
+    m_pListBox->m_bNotifyOwner = true;
+    SetFocus(true);
   }
 }
 
-FX_BOOL IFWL_ComboBox::IsDropListShowed() {
+bool IFWL_ComboBox::IsDropListShowed() {
   return m_pComboBoxProxy &&
          !(m_pComboBoxProxy->GetStates() & FWL_WGTSTATE_Invisible);
 }
 
-FX_BOOL IFWL_ComboBox::IsDropDownStyle() const {
+bool IFWL_ComboBox::IsDropDownStyle() const {
   return m_pProperties->m_dwStyleExes & FWL_STYLEEXT_CMB_DropDown;
 }
 
 void IFWL_ComboBox::MatchEditText() {
   CFX_WideString wsText;
   m_pEdit->GetText(wsText);
   int32_t iMatch = m_pListBox->MatchItem(wsText);
   if (iMatch != m_iCurSel) {
     m_pListBox->ChangeSelected(iMatch);
     if (iMatch >= 0) {
@@ skipping 21 matching lines @@
     return DisForm_Layout();
   }
   GetClientRect(m_rtClient);
   FX_FLOAT* pFWidth = static_cast<FX_FLOAT*>(
       GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
   if (!pFWidth)
     return;
   FX_FLOAT fBtn = *pFWidth;
   m_rtBtn.Set(m_rtClient.right() - fBtn, m_rtClient.top, fBtn,
               m_rtClient.height);
-  FX_BOOL bIsDropDown = IsDropDownStyle();
+  bool bIsDropDown = IsDropDownStyle();
   if (bIsDropDown && m_pEdit) {
     CFX_RectF rtEdit;
     rtEdit.Set(m_rtClient.left, m_rtClient.top, m_rtClient.width - fBtn,
                m_rtClient.height);
     m_pEdit->SetWidgetRect(rtEdit);
     if (m_iCurSel >= 0) {
       CFX_WideString wsText;
       IFWL_ComboBoxDP* pData =
           static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
       IFWL_ListItem* hItem = pData->GetItem(this, m_iCurSel);
@@ skipping 66 matching lines @@
       dwAdd |= FWL_STYLEEXT_LTB_CenterAlign;
     }
     case FWL_STYLEEXT_CMB_ListItemRightAlign: {
       dwAdd |= FWL_STYLEEXT_LTB_RightAlign;
     }
     default: { dwAdd |= FWL_STYLEEXT_LTB_LeftAlign; }
   }
   m_pListBox->ModifyStylesEx(dwAdd, FWL_STYLEEXT_CMB_ListItemAlignMask);
 }
 
-void IFWL_ComboBox::ProcessSelChanged(FX_BOOL bLButtonUp) {
+void IFWL_ComboBox::ProcessSelChanged(bool bLButtonUp) {
   IFWL_ComboBoxDP* pDatas =
       static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
   m_iCurSel = pDatas->GetItemIndex(this, m_pListBox->GetSelItem(0));
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bDropDown = IsDropDownStyle();
   if (bDropDown) {
     IFWL_ComboBoxDP* pData =
         static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
     IFWL_ListItem* hItem = pData->GetItem(this, m_iCurSel);
     if (hItem) {
       CFX_WideString wsText;
       pData->GetItemText(this, hItem, wsText);
       if (m_pEdit) {
         m_pEdit->SetText(wsText);
         m_pEdit->Update();
@@ skipping 43 matching lines @@
   if (m_pEdit)
     return;
 
   CFWL_WidgetImpProperties prop;
   prop.m_pParent = this;
   prop.m_pThemeProvider = m_pProperties->m_pThemeProvider;
   m_pEdit.reset(new IFWL_ComboEdit(m_pOwnerApp, prop, this));
   m_pEdit->SetOuter(this);
 }
 
-void IFWL_ComboBox::DisForm_ShowDropList(FX_BOOL bActivate) {
-  FX_BOOL bDropList = DisForm_IsDropListShowed();
+void IFWL_ComboBox::DisForm_ShowDropList(bool bActivate) {
+  bool bDropList = DisForm_IsDropListShowed();
   if (bDropList == bActivate) {
     return;
   }
   if (bActivate) {
     CFWL_EvtCmbPreDropDown preEvent;
     preEvent.m_pSrcTarget = this;
     DispatchEvent(&preEvent);
     IFWL_ComboList* pComboList = m_pListBox.get();
     int32_t iItems = pComboList->CountItems();
     if (iItems < 1) {
@@ skipping 10 matching lines @@
     FX_FLOAT fPopupMax = fItemHeight * iItems + fBorder * 2;
     CFX_RectF rtList;
     rtList.left = m_rtClient.left;
     rtList.width = m_pProperties->m_rtWidget.width;
     rtList.top = 0;
     rtList.height = 0;
     GetPopupPos(fPopupMin, fPopupMax, m_pProperties->m_rtWidget, rtList);
     m_pListBox->SetWidgetRect(rtList);
     m_pListBox->Update();
   } else {
-    SetFocus(TRUE);
+    SetFocus(true);
   }
   m_pListBox->SetStates(FWL_WGTSTATE_Invisible, !bActivate);
   if (bActivate) {
     CFWL_EvtCmbPostDropDown postEvent;
     postEvent.m_pSrcTarget = this;
     DispatchEvent(&postEvent);
   }
   CFX_RectF rect;
   m_pListBox->GetWidgetRect(rect);
   rect.Inflate(2, 2);
   Repaint(&rect);
 }
 
-FX_BOOL IFWL_ComboBox::DisForm_IsDropListShowed() {
+bool IFWL_ComboBox::DisForm_IsDropListShowed() {
   return !(m_pListBox->GetStates() & FWL_WGTSTATE_Invisible);
 }
 
 FWL_Error IFWL_ComboBox::DisForm_ModifyStylesEx(uint32_t dwStylesExAdded,
                                                 uint32_t dwStylesExRemoved) {
   if (!m_pEdit)
     DisForm_InitComboEdit();
 
   bool bAddDropDown = !!(dwStylesExAdded & FWL_STYLEEXT_CMB_DropDown);
   bool bDelDropDown = !!(dwStylesExRemoved & FWL_STYLEEXT_CMB_DropDown);
@@ skipping 36 matching lines @@
 }
 
 FWL_Error IFWL_ComboBox::DisForm_DrawWidget(CFX_Graphics* pGraphics,
                                             const CFX_Matrix* pMatrix) {
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   CFX_Matrix mtOrg;
   mtOrg.Set(1, 0, 0, 1, 0, 0);
   if (pMatrix) {
     mtOrg = *pMatrix;
   }
-  FX_BOOL bListShowed = m_pListBox && DisForm_IsDropListShowed();
+  bool bListShowed = m_pListBox && DisForm_IsDropListShowed();
   pGraphics->SaveGraphState();
   pGraphics->ConcatMatrix(&mtOrg);
   if (!m_rtBtn.IsEmpty(0.1f)) {
     CFWL_ThemeBackground param;
     param.m_pWidget = this;
     param.m_iPart = CFWL_Part::DropDownButton;
     param.m_dwStates = m_iBtnState;
     param.m_pGraphics = pGraphics;
     param.m_rtPart = m_rtBtn;
     pTheme->DrawBackground(&param);
@@ skipping 41 matching lines @@
   if (!(GetStylesEx() & FWL_STYLEEXT_CMB_ReadOnly)) {
     m_rtBtn.Set(m_rtClient.right() - fBtn, m_rtClient.top + borderWidth,
                 fBtn - borderWidth, m_rtClient.height - 2 * borderWidth);
   }
   CFX_RectF* pUIMargin =
       static_cast<CFX_RectF*>(GetThemeCapacity(CFWL_WidgetCapacity::UIMargin));
   if (pUIMargin) {
     m_rtContent.Deflate(pUIMargin->left, pUIMargin->top, pUIMargin->width,
                         pUIMargin->height);
   }
-  FX_BOOL bIsDropDown = IsDropDownStyle();
+  bool bIsDropDown = IsDropDownStyle();
   if (bIsDropDown && m_pEdit) {
     CFX_RectF rtEdit;
     rtEdit.Set(m_rtContent.left, m_rtContent.top, m_rtContent.width - fBtn,
                m_rtContent.height);
     m_pEdit->SetWidgetRect(rtEdit);
     if (m_iCurSel >= 0) {
       CFX_WideString wsText;
       IFWL_ComboBoxDP* pData =
           static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
       IFWL_ListItem* hItem = pData->GetItem(this, m_iCurSel);
       m_pListBox->GetItemText(hItem, wsText);
       m_pEdit->LockUpdate();
       m_pEdit->SetText(wsText);
       m_pEdit->UnlockUpdate();
     }
     m_pEdit->Update();
   }
 }
 
 void IFWL_ComboBox::OnProcessMessage(CFWL_Message* pMessage) {
   if (m_pWidgetMgr->IsFormDisabled()) {
     DisForm_OnProcessMessage(pMessage);
     return;
   }
   if (!pMessage)
     return;
 
   switch (pMessage->GetClassID()) {
     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 46 matching lines @@
     pTemp.nChangeType = pTextChangedEvent->nChangeType;
     DispatchEvent(&pTemp);
   }
 }
 
 void IFWL_ComboBox::OnDrawWidget(CFX_Graphics* pGraphics,
                                  const CFX_Matrix* pMatrix) {
   DrawWidget(pGraphics, pMatrix);
 }
 
-void IFWL_ComboBox::OnFocusChanged(CFWL_Message* pMsg, FX_BOOL bSet) {
+void IFWL_ComboBox::OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
   IFWL_Widget* pDstTarget = pMsg->m_pDstTarget;
   IFWL_Widget* pSrcTarget = pMsg->m_pSrcTarget;
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bDropDown = IsDropDownStyle();
   if (bSet) {
     m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
     if (bDropDown && pSrcTarget != m_pListBox.get()) {
       if (!m_pEdit)
         return;
       m_pEdit->SetSelected();
     } else {
       Repaint(&m_rtClient);
     }
   } else {
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
     if (bDropDown && pDstTarget != m_pListBox.get()) {
       if (!m_pEdit)
         return;
-      m_pEdit->FlagFocus(FALSE);
+      m_pEdit->FlagFocus(false);
       m_pEdit->ClearSelected();
     } else {
       Repaint(&m_rtClient);
     }
   }
 }
 
 void IFWL_ComboBox::OnLButtonDown(CFWL_MsgMouse* pMsg) {
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
     return;
 
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bDropDown = IsDropDownStyle();
   CFX_RectF& rtBtn = bDropDown ? m_rtBtn : m_rtClient;
-  FX_BOOL bClickBtn = rtBtn.Contains(pMsg->m_fx, pMsg->m_fy);
+  bool bClickBtn = rtBtn.Contains(pMsg->m_fx, pMsg->m_fy);
   if (!bClickBtn)
     return;
 
   if (bDropDown && m_pEdit)
     MatchEditText();
 
-  m_bLButtonDown = TRUE;
+  m_bLButtonDown = true;
   m_iBtnState = CFWL_PartState_Pressed;
   Repaint(&m_rtClient);
-  ShowDropList(TRUE);
+  ShowDropList(true);
   m_iBtnState = CFWL_PartState_Normal;
   Repaint(&m_rtClient);
 }
 
 void IFWL_ComboBox::OnLButtonUp(CFWL_MsgMouse* pMsg) {
-  m_bLButtonDown = FALSE;
+  m_bLButtonDown = false;
   if (m_rtBtn.Contains(pMsg->m_fx, pMsg->m_fy))
     m_iBtnState = CFWL_PartState_Hovered;
   else
     m_iBtnState = CFWL_PartState_Normal;
 
   Repaint(&m_rtBtn);
 }
 
 void IFWL_ComboBox::OnMouseMove(CFWL_MsgMouse* pMsg) {
   int32_t iOldState = m_iBtnState;
@@ skipping 31 matching lines @@
 
 void IFWL_ComboBox::DoSubCtrlKey(CFWL_MsgKey* pMsg) {
   uint32_t dwKeyCode = pMsg->m_dwKeyCode;
   const bool bUp = dwKeyCode == FWL_VKEY_Up;
   const bool bDown = dwKeyCode == FWL_VKEY_Down;
   if (bUp || bDown) {
     int32_t iCount = m_pListBox->CountItems();
     if (iCount < 1)
       return;
 
-    FX_BOOL bMatchEqual = FALSE;
+    bool bMatchEqual = false;
     int32_t iCurSel = m_iCurSel;
-    FX_BOOL bDropDown = IsDropDownStyle();
+    bool bDropDown = IsDropDownStyle();
     if (bDropDown && m_pEdit) {
       CFX_WideString wsText;
       m_pEdit->GetText(wsText);
       iCurSel = m_pListBox->MatchItem(wsText);
       if (iCurSel >= 0) {
         CFX_WideString wsTemp;
         IFWL_ComboBoxDP* pData =
             static_cast<IFWL_ComboBoxDP*>(m_pProperties->m_pDataProvider);
         IFWL_ListItem* hItem = pData->GetItem(this, iCurSel);
         m_pListBox->GetItemText(hItem, wsTemp);
@@ skipping 11 matching lines @@
         iCurSel++;
     }
     m_iCurSel = iCurSel;
     if (bDropDown && m_pEdit)
       SynchrEditText(m_iCurSel);
     else
       Repaint(&m_rtClient);
     return;
   }
 
-  FX_BOOL bDropDown = IsDropDownStyle();
+  bool bDropDown = IsDropDownStyle();
   if (bDropDown)
     m_pEdit->GetDelegate()->OnProcessMessage(pMsg);
 }
 
 void IFWL_ComboBox::DisForm_OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
     return;
 
-  FX_BOOL backDefault = TRUE;
+  bool backDefault = true;
   switch (pMessage->GetClassID()) {
     case CFWL_MessageType::SetFocus: {
-      backDefault = FALSE;
-      DisForm_OnFocusChanged(pMessage, TRUE);
+      backDefault = false;
+      DisForm_OnFocusChanged(pMessage, true);
       break;
     }
     case CFWL_MessageType::KillFocus: {
-      backDefault = FALSE;
-      DisForm_OnFocusChanged(pMessage, FALSE);
+      backDefault = false;
+      DisForm_OnFocusChanged(pMessage, false);
       break;
     }
     case CFWL_MessageType::Mouse: {
-      backDefault = FALSE;
+      backDefault = false;
       CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage);
       switch (pMsg->m_dwCmd) {
         case FWL_MouseCommand::LeftButtonDown:
           DisForm_OnLButtonDown(pMsg);
           break;
         case FWL_MouseCommand::LeftButtonUp:
           OnLButtonUp(pMsg);
           break;
         default:
           break;
       }
       break;
     }
     case CFWL_MessageType::Key: {
-      backDefault = FALSE;
+      backDefault = false;
       CFWL_MsgKey* pKey = static_cast<CFWL_MsgKey*>(pMessage);
       if (pKey->m_dwCmd == FWL_KeyCommand::KeyUp)
         break;
       if (DisForm_IsDropListShowed() &&
           pKey->m_dwCmd == FWL_KeyCommand::KeyDown) {
-        FX_BOOL bListKey = pKey->m_dwKeyCode == FWL_VKEY_Up ||
-                           pKey->m_dwKeyCode == FWL_VKEY_Down ||
-                           pKey->m_dwKeyCode == FWL_VKEY_Return ||
-                           pKey->m_dwKeyCode == FWL_VKEY_Escape;
+        bool bListKey = pKey->m_dwKeyCode == FWL_VKEY_Up ||
+                        pKey->m_dwKeyCode == FWL_VKEY_Down ||
+                        pKey->m_dwKeyCode == FWL_VKEY_Return ||
+                        pKey->m_dwKeyCode == FWL_VKEY_Escape;
         if (bListKey) {
           m_pListBox->GetDelegate()->OnProcessMessage(pMessage);
           break;
         }
       }
       DisForm_OnKey(pKey);
       break;
     }
     default:
       break;
   }
   if (backDefault)
     IFWL_Widget::OnProcessMessage(pMessage);
 }
 
 void IFWL_ComboBox::DisForm_OnLButtonDown(CFWL_MsgMouse* pMsg) {
-  FX_BOOL bDropDown = DisForm_IsDropListShowed();
+  bool bDropDown = DisForm_IsDropListShowed();
   CFX_RectF& rtBtn = bDropDown ? m_rtBtn : m_rtClient;
   if (!rtBtn.Contains(pMsg->m_fx, pMsg->m_fy))
     return;
 
   if (DisForm_IsDropListShowed()) {
-    DisForm_ShowDropList(FALSE);
+    DisForm_ShowDropList(false);
     return;
   }
   if (m_pEdit)
     MatchEditText();
-  DisForm_ShowDropList(TRUE);
+  DisForm_ShowDropList(true);
 }
 
-void IFWL_ComboBox::DisForm_OnFocusChanged(CFWL_Message* pMsg, FX_BOOL bSet) {
+void IFWL_ComboBox::DisForm_OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
   if (bSet) {
     m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
     if ((m_pEdit->GetStates() & FWL_WGTSTATE_Focused) == 0) {
       CFWL_MsgSetFocus msg;
       msg.m_pDstTarget = m_pEdit.get();
       msg.m_pSrcTarget = nullptr;
       m_pEdit->GetDelegate()->OnProcessMessage(&msg);
     }
   } else {
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
-    DisForm_ShowDropList(FALSE);
+    DisForm_ShowDropList(false);
     CFWL_MsgKillFocus msg;
     msg.m_pDstTarget = nullptr;
     msg.m_pSrcTarget = m_pEdit.get();
     m_pEdit->GetDelegate()->OnProcessMessage(&msg);
   }
 }
 
 void IFWL_ComboBox::DisForm_OnKey(CFWL_MsgKey* pMsg) {
   uint32_t dwKeyCode = pMsg->m_dwKeyCode;
   const bool bUp = dwKeyCode == FWL_VKEY_Up;
   const bool bDown = dwKeyCode == FWL_VKEY_Down;
   if (bUp || bDown) {
     IFWL_ComboList* pComboList = m_pListBox.get();
     int32_t iCount = pComboList->CountItems();
     if (iCount < 1)
       return;
 
-    FX_BOOL bMatchEqual = FALSE;
+    bool bMatchEqual = false;
     int32_t iCurSel = m_iCurSel;
     if (m_pEdit) {
       CFX_WideString wsText;
       m_pEdit->GetText(wsText);
       iCurSel = pComboList->MatchItem(wsText);
       if (iCurSel >= 0) {
         CFX_WideString wsTemp;
         IFWL_ListItem* item = m_pListBox->GetSelItem(iCurSel);
         m_pListBox->GetItemText(item, wsTemp);
         bMatchEqual = wsText == wsTemp;
       }
     }
     if (iCurSel < 0) {
       iCurSel = 0;
     } else if (bMatchEqual) {
       if ((bUp && iCurSel == 0) || (bDown && iCurSel == iCount - 1))
         return;
       if (bUp)
         iCurSel--;
       else
         iCurSel++;
     }
     m_iCurSel = iCurSel;
     SynchrEditText(m_iCurSel);
     return;
   }
   if (m_pEdit)
     m_pEdit->GetDelegate()->OnProcessMessage(pMsg);
 }