Remove FX_BOOL from xfa.

xfa/fwl/core/ifwl_form.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_form.h"
 
 #include "third_party/base/ptr_util.h"
 #include "xfa/fde/tto/fde_textout.h"
@@ skipping 33 matching lines @@
       m_pCloseBox(nullptr),
       m_pMinBox(nullptr),
       m_pMaxBox(nullptr),
       m_pCaptionBox(nullptr),
       m_pSubFocus(nullptr),
       m_fCXBorder(0),
       m_fCYBorder(0),
       m_iCaptureBtn(-1),
       m_iSysBox(0),
       m_eResizeType(FORM_RESIZETYPE_None),
-      m_bLButtonDown(FALSE),
+      m_bLButtonDown(false),
       m_bMaximized(false),
-      m_bSetMaximize(FALSE),
+      m_bSetMaximize(false),
       m_bCustomizeLayout(false),
       m_eFormSize(FWL_FORMSIZE_Manual),
-      m_bDoModalFlag(FALSE),
+      m_bDoModalFlag(false),
       m_pBigIcon(nullptr),
       m_pSmallIcon(nullptr),
-      m_bMouseIn(FALSE) {
+      m_bMouseIn(false) {
   m_rtRelative.Reset();
   m_rtCaption.Reset();
   m_rtRestore.Reset();
   m_rtCaptionText.Reset();
   m_rtIcon.Reset();
 
   RegisterForm();
   RegisterEventTarget();
 }
 
 IFWL_Form::~IFWL_Form() {
   UnregisterEventTarget();
   UnRegisterForm();
   RemoveSysButtons();
 }
 
 FWL_Type IFWL_Form::GetClassID() const {
   return FWL_Type::Form;
 }
 
-FX_BOOL IFWL_Form::IsInstance(const CFX_WideStringC& wsClass) const {
+bool IFWL_Form::IsInstance(const CFX_WideStringC& wsClass) const {
   if (wsClass == CFX_WideStringC(FWL_CLASS_Form))
-    return TRUE;
+    return true;
   return IFWL_Widget::IsInstance(wsClass);
 }
 
-FWL_Error IFWL_Form::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
+FWL_Error IFWL_Form::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
     rect.Reset();
     FX_FLOAT fCapHeight = GetCaptionHeight();
-    FX_FLOAT fCXBorder = GetBorderSize(TRUE);
-    FX_FLOAT fCYBorder = GetBorderSize(FALSE);
+    FX_FLOAT fCXBorder = GetBorderSize(true);
+    FX_FLOAT fCYBorder = GetBorderSize(false);
     FX_FLOAT fEdge = GetEdgeWidth();
     rect.height += fCapHeight + fCYBorder + fEdge + fEdge;
     rect.width += fCXBorder + fCXBorder + fEdge + fEdge;
   } else {
     rect = m_pProperties->m_rtWidget;
   }
   return FWL_Error::Succeeded;
 }
 FWL_Error IFWL_Form::GetClientRect(CFX_RectF& rect) {
   if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_Caption) == 0) {
@@ skipping 101 matching lines @@
   }
   return FWL_WidgetHit::Client;
 }
 FWL_Error IFWL_Form::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;
-  FX_BOOL bInactive = !IsActive();
+  bool bInactive = !IsActive();
   int32_t iState = bInactive ? CFWL_PartState_Inactive : CFWL_PartState_Normal;
   if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_FRM_NoDrawClient) == 0) {
     DrawBackground(pGraphics, pTheme);
   }
 #ifdef FWL_UseMacSystemBorder
   return FWL_Error::Succeeded;
 #endif
   CFWL_ThemeBackground param;
   param.m_pWidget = this;
   param.m_dwStates = iState;
@@ skipping 63 matching lines @@
       param.m_iPart = CFWL_Part::MinimizeBox;
       param.m_dwStates = m_pMinBox->GetPartState();
       if (m_pProperties->m_dwStates & FWL_WGTSTATE_Deactivated) {
         param.m_dwStates = CFWL_PartState_Disabled;
       } else if (CFWL_PartState_Normal == param.m_dwStates && m_bMouseIn) {
         param.m_dwStates = CFWL_PartState_Hovered;
       }
       param.m_rtPart = m_pMinBox->m_rtBtn;
       pTheme->DrawBackground(&param);
     }
-    m_bMouseIn = FALSE;
+    m_bMouseIn = false;
   }
 #else
   {
     if (m_pCloseBox) {
       param.m_iPart = CFWL_Part::CloseBox;
       param.m_dwStates = m_pCloseBox->GetPartState();
       param.m_rtPart = m_pCloseBox->m_rtBtn;
       pTheme->DrawBackground(&param);
     }
     if (m_pMaxBox) {
@@ skipping 27 matching lines @@
   const IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
     return nullptr;
 
   CFWL_NoteDriver* pDriver = pApp->GetNoteDriver();
   if (!pDriver)
     return nullptr;
 
   m_pNoteLoop.reset(new CFWL_NoteLoop(this));
   pDriver->PushNoteLoop(m_pNoteLoop.get());
-  m_bDoModalFlag = TRUE;
-  SetStates(FWL_WGTSTATE_Invisible, FALSE);
+  m_bDoModalFlag = true;
+  SetStates(FWL_WGTSTATE_Invisible, false);
   pDriver->Run();
 #if (_FX_OS_ == _FX_MACOSX_)
 #else
   pDriver->PopNoteLoop();
 #endif
   m_pNoteLoop.reset();
   return nullptr;
 }
 
 IFWL_Widget* IFWL_Form::DoModal(uint32_t& dwCommandID) {
   return DoModal();
 }
 
 FWL_Error IFWL_Form::EndDoModal() {
   if (!m_pNoteLoop)
     return FWL_Error::Indefinite;
-  m_bDoModalFlag = FALSE;
+  m_bDoModalFlag = false;
 #if (_FX_OS_ == _FX_MACOSX_)
   m_pNoteLoop->EndModalLoop();
   const IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
     return FWL_Error::Indefinite;
 
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
   if (!pDriver)
     return FWL_Error::Indefinite;
 
   pDriver->PopNoteLoop();
-  SetStates(FWL_WGTSTATE_Invisible, TRUE);
+  SetStates(FWL_WGTSTATE_Invisible, true);
   return FWL_Error::Succeeded;
 #else
-  SetStates(FWL_WGTSTATE_Invisible, TRUE);
+  SetStates(FWL_WGTSTATE_Invisible, true);
   return m_pNoteLoop->EndModalLoop();
 #endif
 }
 
 FWL_Error IFWL_Form::SetBorderRegion(CFX_Path* pPath) {
   return FWL_Error::Succeeded;
 }
 void IFWL_Form::DrawBackground(CFX_Graphics* pGraphics,
                                IFWL_ThemeProvider* pTheme) {
   CFWL_ThemeBackground param;
@@ skipping 161 matching lines @@
 }
 void IFWL_Form::DrawIconImage(CFX_Graphics* pGs,
                               IFWL_ThemeProvider* pTheme,
                               const CFX_Matrix* pMatrix) {
   IFWL_FormDP* pData =
       static_cast<IFWL_FormDP*>(m_pProperties->m_pDataProvider);
   CFWL_ThemeBackground param;
   param.m_pWidget = this;
   param.m_iPart = CFWL_Part::Icon;
   param.m_pGraphics = pGs;
-  param.m_pImage = pData->GetIcon(this, FALSE);
+  param.m_pImage = pData->GetIcon(this, false);
   param.m_rtPart = m_rtIcon;
   if (pMatrix) {
     param.m_matrix.Concat(*pMatrix);
   }
   pTheme->DrawBackground(&param);
 }
 void IFWL_Form::GetEdgeRect(CFX_RectF& rtEdge) {
   rtEdge = m_rtRelative;
   if (m_pProperties->m_dwStyles & FWL_WGTSTYLE_Border) {
     FX_FLOAT fCX = GetBorderSize();
-    FX_FLOAT fCY = GetBorderSize(FALSE);
+    FX_FLOAT fCY = GetBorderSize(false);
     rtEdge.Deflate(fCX, m_rtCaption.Height(), fCX, fCY);
   }
 }
 void IFWL_Form::SetWorkAreaRect() {
   m_rtRestore = m_pProperties->m_rtWidget;
   CFWL_WidgetMgr* pWidgetMgr = GetOwnerApp()->GetWidgetMgr();
   if (!pWidgetMgr)
     return;
-  m_bSetMaximize = TRUE;
+  m_bSetMaximize = true;
   Repaint(&m_rtRelative);
 }
 void IFWL_Form::SetCursor(FX_FLOAT fx, FX_FLOAT fy) {}
 void IFWL_Form::Layout() {
   GetRelativeRect(m_rtRelative);
 #ifndef FWL_UseMacSystemBorder
   ReSetSysBtn();
 #endif
 }
 void IFWL_Form::ReSetSysBtn() {
@@ skipping 49 matching lines @@
         m_pMinBox->m_rtBtn.Set(
             m_rtRelative.right() - kSystemButtonMargin - kSystemButtonSize,
             kSystemButtonMargin, kSystemButtonSize, kSystemButtonSize);
       }
     }
     m_iSysBox++;
   }
   IFWL_FormDP* pData =
       static_cast<IFWL_FormDP*>(m_pProperties->m_pDataProvider);
   if (m_pProperties->m_dwStyles & FWL_WGTSTYLE_Icon &&
-      pData->GetIcon(this, FALSE)) {
+      pData->GetIcon(this, false)) {
     if (!m_bCustomizeLayout) {
       m_rtIcon.Set(5, (m_rtCaption.height - m_fSmallIconSz) / 2, m_fSmallIconSz,
                    m_fSmallIconSz);
     }
   }
 }
 void IFWL_Form::RegisterForm() {
   const IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
     return;
@@ skipping 10 matching lines @@
   if (!pApp)
     return;
 
   CFWL_NoteDriver* pDriver =
       static_cast<CFWL_NoteDriver*>(pApp->GetNoteDriver());
   if (!pDriver)
     return;
 
   pDriver->UnRegisterForm(this);
 }
-FX_BOOL IFWL_Form::IsDoModal() {
+bool IFWL_Form::IsDoModal() {
   return m_bDoModalFlag;
 }
 void IFWL_Form::SetThemeData() {
   m_fSmallIconSz =
       *static_cast<FX_FLOAT*>(GetThemeCapacity(CFWL_WidgetCapacity::SmallIcon));
   m_fBigIconSz =
       *static_cast<FX_FLOAT*>(GetThemeCapacity(CFWL_WidgetCapacity::BigIcon));
 }
-FX_BOOL IFWL_Form::HasIcon() {
+bool IFWL_Form::HasIcon() {
   IFWL_FormDP* pData =
       static_cast<IFWL_FormDP*>(m_pProperties->m_pDataProvider);
-  return !!pData->GetIcon(this, FALSE);
+  return !!pData->GetIcon(this, false);
 }
 void IFWL_Form::UpdateIcon() {
   CFWL_WidgetMgr* pWidgetMgr = GetOwnerApp()->GetWidgetMgr();
   if (!pWidgetMgr)
     return;
   IFWL_FormDP* pData =
       static_cast<IFWL_FormDP*>(m_pProperties->m_pDataProvider);
-  CFX_DIBitmap* pBigIcon = pData->GetIcon(this, TRUE);
-  CFX_DIBitmap* pSmallIcon = pData->GetIcon(this, FALSE);
+  CFX_DIBitmap* pBigIcon = pData->GetIcon(this, true);
+  CFX_DIBitmap* pSmallIcon = pData->GetIcon(this, false);
   if (pBigIcon)
     m_pBigIcon = pBigIcon;
   if (pSmallIcon)
     m_pSmallIcon = pSmallIcon;
 }
 void IFWL_Form::UpdateCaption() {
   CFWL_WidgetMgr* pWidgetMgr = GetOwnerApp()->GetWidgetMgr();
   if (!pWidgetMgr)
     return;
   IFWL_DataProvider* pData = m_pProperties->m_pDataProvider;
   if (!pData)
     return;
   CFX_WideString text;
   pData->GetCaption(this, text);
 }
 void IFWL_Form::DoWidthLimit(FX_FLOAT& fLeft,
                              FX_FLOAT& fWidth,
                              FX_FLOAT fCurX,
                              FX_FLOAT fSpace,
                              FX_FLOAT fLimitMin,
                              FX_FLOAT fLimitMax,
-                             FX_BOOL bLeft) {
+                             bool bLeft) {
   FX_FLOAT fx = fCurX;
   FX_FLOAT fy = 0;
   TransformTo(nullptr, fx, fy);
   FX_FLOAT fTemp =
       bLeft ? (fWidth - fx + fLeft + fSpace) : (fx - fLeft + fSpace);
   if (fTemp >= fLimitMin && fTemp <= fLimitMax) {
     fWidth = fTemp;
     fLeft += bLeft ? (fx - fLeft - fSpace) : 0;
   } else {
     if (fTemp < fLimitMin && fWidth > fLimitMin) {
       fLeft += bLeft ? (fWidth - fLimitMin) : 0;
       fWidth = fLimitMin;
     } else if (fTemp > fLimitMax && fWidth < fLimitMax) {
       fLeft -= bLeft ? (fLimitMax - fWidth) : 0;
       fWidth = fLimitMax;
     }
   }
 }
 void IFWL_Form::DoHeightLimit(FX_FLOAT& fTop,
                               FX_FLOAT& fHeight,
                               FX_FLOAT fCurY,
                               FX_FLOAT fSpace,
                               FX_FLOAT fLimitMin,
                               FX_FLOAT fLimitMax,
-                              FX_BOOL bTop) {
+                              bool bTop) {
   FX_FLOAT fx = 0;
   FX_FLOAT fy = fCurY;
   TransformTo(nullptr, fx, fy);
   FX_FLOAT fTemp = bTop ? (fHeight - fy + fTop + fSpace) : (fy - fTop + fSpace);
   if (fTemp >= fLimitMin && fTemp <= fLimitMax) {
     fHeight = fTemp;
     fTop += bTop ? (fy - fTop - fSpace) : 0;
   } else {
     if (fTemp < fLimitMin && fHeight > fLimitMin) {
       fTop += bTop ? (fHeight - fLimitMin) : 0;
@@ skipping 90 matching lines @@
     }
     case CFWL_MessageType::Size: {
       CFWL_WidgetMgr* pWidgetMgr = GetOwnerApp()->GetWidgetMgr();
       if (!pWidgetMgr)
         return;
 
       pWidgetMgr->AddRedrawCounts(this);
       if (!m_bSetMaximize)
         break;
 
-      m_bSetMaximize = FALSE;
+      m_bSetMaximize = false;
       CFWL_MsgSize* pMsg = static_cast<CFWL_MsgSize*>(pMessage);
       m_pProperties->m_rtWidget.left = 0;
       m_pProperties->m_rtWidget.top = 0;
       m_pProperties->m_rtWidget.width = (FX_FLOAT)pMsg->m_iWidth;
       m_pProperties->m_rtWidget.height = (FX_FLOAT)pMsg->m_iHeight;
       Update();
       break;
     }
     case CFWL_MessageType::WindowMove:
       OnWindowMove(static_cast<CFWL_MsgWindowMove*>(pMessage));
       break;
     case CFWL_MessageType::Close:
       OnClose(static_cast<CFWL_MsgClose*>(pMessage));
       break;
     default:
       break;
   }
 }
 #endif  // FWL_UseMacSystemBorder
 
 void IFWL_Form::OnDrawWidget(CFX_Graphics* pGraphics,
                              const CFX_Matrix* pMatrix) {
   DrawWidget(pGraphics, pMatrix);
 }
 
 void IFWL_Form::OnLButtonDown(CFWL_MsgMouse* pMsg) {
-  SetGrab(TRUE);
-  m_bLButtonDown = TRUE;
+  SetGrab(true);
+  m_bLButtonDown = true;
   m_eResizeType = FORM_RESIZETYPE_None;
   CFWL_SysBtn* pPressBtn = GetSysBtnAtPoint(pMsg->m_fx, pMsg->m_fy);
   m_iCaptureBtn = GetSysBtnIndex(pPressBtn);
   CFX_RectF rtCap;
   rtCap.Set(m_rtCaption.left + m_fCYBorder, m_rtCaption.top + m_fCXBorder,
             m_rtCaption.width - kSystemButtonSize * m_iSysBox - 2 * m_fCYBorder,
             m_rtCaption.height - m_fCXBorder);
 
   if (pPressBtn) {
     pPressBtn->SetPressed();
     Repaint(&pPressBtn->m_rtBtn);
   } else if (rtCap.Contains(pMsg->m_fx, pMsg->m_fy)) {
     m_eResizeType = FORM_RESIZETYPE_Cap;
   } else if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_Border) &&
              (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_FRM_Resize) &&
              !m_bMaximized) {
     SetCursor(pMsg->m_fx, pMsg->m_fy);
   }
   m_InfoStart.m_ptStart = CFX_PointF(pMsg->m_fx, pMsg->m_fy);
   m_InfoStart.m_szStart = CFX_SizeF(m_pProperties->m_rtWidget.width,
                                     m_pProperties->m_rtWidget.height);
 }
 
 void IFWL_Form::OnLButtonUp(CFWL_MsgMouse* pMsg) {
-  SetGrab(FALSE);
-  m_bLButtonDown = FALSE;
+  SetGrab(false);
+  m_bLButtonDown = false;
   CFWL_SysBtn* pPointBtn = GetSysBtnAtPoint(pMsg->m_fx, pMsg->m_fy);
   CFWL_SysBtn* pPressedBtn = GetSysBtnByIndex(m_iCaptureBtn);
   if (!pPressedBtn || pPointBtn != pPressedBtn)
     return;
   if (pPressedBtn == GetSysBtnByState(FWL_SYSBUTTONSTATE_Pressed))
     pPressedBtn->SetNormal();
   if (pPressedBtn == m_pMaxBox) {
     if (m_bMaximized) {
       SetWidgetRect(m_rtRestore);
       Update();
@@ skipping 38 matching lines @@
         rtInvalidate.Union(m_pMaxBox->m_rtBtn);
     }
     if (m_pMinBox) {
       if (rtInvalidate.IsEmpty())
         rtInvalidate = m_pMinBox->m_rtBtn;
       else
         rtInvalidate.Union(m_pMinBox->m_rtBtn);
     }
     if (!rtInvalidate.IsEmpty() &&
         rtInvalidate.Contains(pMsg->m_fx, pMsg->m_fy)) {
-      m_bMouseIn = TRUE;
+      m_bMouseIn = true;
     }
   }
 #else
   {
     if (pOldHover && pPointBtn != pOldHover) {
       pOldHover->SetNormal();
       rtInvalidate = pOldHover->m_rtBtn;
     }
     if (pPointBtn && pPointBtn != pOldHover) {
       pPointBtn->SetHover();
@@ skipping 62 matching lines @@
 void CFWL_SysBtn::SetPressed() {
   SetNormal();
   m_dwState |= FWL_SYSBUTTONSTATE_Pressed;
 }
 
 void CFWL_SysBtn::SetHover() {
   SetNormal();
   m_dwState |= FWL_SYSBUTTONSTATE_Hover;
 }
 
-void CFWL_SysBtn::SetDisabled(FX_BOOL bDisabled) {
+void CFWL_SysBtn::SetDisabled(bool bDisabled) {
   bDisabled ? m_dwState |= FWL_SYSBUTTONSTATE_Disabled
             : m_dwState &= ~FWL_SYSBUTTONSTATE_Disabled;
 }
 
 uint32_t CFWL_SysBtn::GetPartState() const {
   if (IsDisabled())
     return CFWL_PartState_Disabled;
   if (m_dwState & FWL_SYSBUTTONSTATE_Pressed)
     return CFWL_PartState_Pressed;
   if (m_dwState & FWL_SYSBUTTONSTATE_Hover)
     return CFWL_PartState_Hovered;
   return CFWL_PartState_Normal;
 }