Remove FX_BOOL from fpdfsdk.

fpdfsdk/pdfwindow/PWL_Wnd.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 <map>
 
 #include "fpdfsdk/pdfwindow/PWL_ScrollBar.h"
 #include "fpdfsdk/pdfwindow/PWL_Utils.h"
@@ skipping 99 matching lines @@
 
   ~CPWL_MsgControl() { Default(); }
 
   void Default() {
     m_aMousePath.RemoveAll();
     m_aKeyboardPath.RemoveAll();
     m_pMainMouseWnd = nullptr;
     m_pMainKeyboardWnd = nullptr;
   }
 
-  FX_BOOL IsWndCreated(const CPWL_Wnd* pWnd) const {
+  bool IsWndCreated(const CPWL_Wnd* pWnd) const {
     return m_pCreatedWnd == pWnd;
   }
 
-  FX_BOOL IsMainCaptureMouse(const CPWL_Wnd* pWnd) const {
+  bool IsMainCaptureMouse(const CPWL_Wnd* pWnd) const {
     return pWnd == m_pMainMouseWnd;
   }
 
-  FX_BOOL IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
+  bool IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
     if (pWnd) {
       for (int32_t i = 0, sz = m_aMousePath.GetSize(); i < sz; i++) {
         if (m_aMousePath.GetAt(i) == pWnd)
-          return TRUE;
+          return true;
       }
     }
 
-    return FALSE;
+    return false;
   }
 
-  FX_BOOL IsMainCaptureKeyboard(const CPWL_Wnd* pWnd) const {
+  bool IsMainCaptureKeyboard(const CPWL_Wnd* pWnd) const {
     return pWnd == m_pMainKeyboardWnd;
   }
 
-  FX_BOOL IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
+  bool IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
     if (pWnd) {
       for (int32_t i = 0, sz = m_aKeyboardPath.GetSize(); i < sz; i++) {
         if (m_aKeyboardPath.GetAt(i) == pWnd)
-          return TRUE;
+          return true;
       }
     }
 
-    return FALSE;
+    return false;
   }
 
   void SetFocus(CPWL_Wnd* pWnd) {
     m_aKeyboardPath.RemoveAll();
 
     if (pWnd) {
       m_pMainKeyboardWnd = pWnd;
 
       CPWL_Wnd* pParent = pWnd;
       while (pParent) {
@@ skipping 38 matching lines @@
   CFX_ArrayTemplate<CPWL_Wnd*> m_aKeyboardPath;
   CPWL_Wnd* m_pCreatedWnd;
   CPWL_Wnd* m_pMainMouseWnd;
   CPWL_Wnd* m_pMainKeyboardWnd;
 };
 
 CPWL_Wnd::CPWL_Wnd()
     : m_pVScrollBar(nullptr),
       m_rcWindow(),
       m_rcClip(),
-      m_bCreated(FALSE),
-      m_bVisible(FALSE),
-      m_bNotifying(FALSE),
-      m_bEnabled(TRUE) {}
+      m_bCreated(false),
+      m_bVisible(false),
+      m_bNotifying(false),
+      m_bEnabled(true) {}
 
 CPWL_Wnd::~CPWL_Wnd() {
-  ASSERT(m_bCreated == FALSE);
+  ASSERT(m_bCreated == false);
 }
 
 CFX_ByteString CPWL_Wnd::GetClassName() const {
   return "CPWL_Wnd";
 }
 
 void CPWL_Wnd::Create(const PWL_CREATEPARAM& cp) {
   if (!IsValid()) {
     m_sPrivateParam = cp;
 
@@ skipping 14 matching lines @@
     ccp.mtChild = CFX_Matrix(1, 0, 0, 1, 0, 0);
 
     CreateScrollBar(ccp);
     CreateChildWnd(ccp);
 
     m_bVisible = HasFlag(PWS_VISIBLE);
 
     OnCreated();
 
     RePosChildWnd();
-    m_bCreated = TRUE;
+    m_bCreated = true;
   }
 }
 
 void CPWL_Wnd::OnCreate(PWL_CREATEPARAM& cp) {}
 
 void CPWL_Wnd::OnCreated() {}
 
 void CPWL_Wnd::OnDestroy() {}
 
 void CPWL_Wnd::InvalidateFocusHandler(IPWL_FocusHandler* handler) {
@@ skipping 15 matching lines @@
     for (int32_t i = m_aChildren.GetSize() - 1; i >= 0; i--) {
       if (CPWL_Wnd* pChild = m_aChildren[i]) {
         pChild->Destroy();
         delete pChild;
         pChild = nullptr;
       }
     }
 
     if (m_sPrivateParam.pParentWnd)
       m_sPrivateParam.pParentWnd->OnNotify(this, PNM_REMOVECHILD);
-    m_bCreated = FALSE;
+    m_bCreated = false;
   }
 
   DestroyMsgControl();
 
   FXSYS_memset(&m_sPrivateParam, 0, sizeof(PWL_CREATEPARAM));
   m_aChildren.RemoveAll();
   m_pVScrollBar = nullptr;
 }
 
-void CPWL_Wnd::Move(const CFX_FloatRect& rcNew,
-                    FX_BOOL bReset,
-                    FX_BOOL bRefresh) {
+void CPWL_Wnd::Move(const CFX_FloatRect& rcNew, bool bReset, bool bRefresh) {
   if (IsValid()) {
     CFX_FloatRect rcOld = GetWindowRect();
 
     m_rcWindow = rcNew;
     m_rcWindow.Normalize();
 
     if (rcOld.left != rcNew.left || rcOld.right != rcNew.right ||
         rcOld.top != rcNew.top || rcOld.bottom != rcNew.bottom) {
       if (bReset) {
         RePosChildWnd();
@@ skipping 112 matching lines @@
     rcWin.bottom += PWL_INVALIDATE_INFLATE;
 
     if (CFX_SystemHandler* pSH = GetSystemHandler()) {
       if (CPDFSDK_Widget* widget = m_sPrivateParam.pAttachedWidget)
         pSH->InvalidateRect(widget, rcWin);
     }
   }
 }
 
 #define PWL_IMPLEMENT_KEY_METHOD(key_method_name)                      \
-  FX_BOOL CPWL_Wnd::key_method_name(uint16_t nChar, uint32_t nFlag) {  \
+  bool CPWL_Wnd::key_method_name(uint16_t nChar, uint32_t nFlag) {     \
     if (IsValid() && IsVisible() && IsEnabled()) {                     \
       if (IsWndCaptureKeyboard(this)) {                                \
         for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) { \
           if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {               \
             if (IsWndCaptureKeyboard(pChild)) {                        \
               return pChild->key_method_name(nChar, nFlag);            \
             }                                                          \
           }                                                            \
         }                                                              \
       }                                                                \
     }                                                                  \
-    return FALSE;                                                      \
+    return false;                                                      \
   }
 
 #define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)                        \
-  FX_BOOL CPWL_Wnd::mouse_method_name(const CFX_FloatPoint& point,           \
-                                      uint32_t nFlag) {                      \
+  bool CPWL_Wnd::mouse_method_name(const CFX_FloatPoint& point,              \
+                                   uint32_t nFlag) {                         \
     if (IsValid() && IsVisible() && IsEnabled()) {                           \
       if (IsWndCaptureMouse(this)) {                                         \
         for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {       \
           if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {                     \
             if (IsWndCaptureMouse(pChild)) {                                 \
               return pChild->mouse_method_name(pChild->ParentToChild(point), \
                                                nFlag);                       \
             }                                                                \
           }                                                                  \
         }                                                                    \
         SetCursor();                                                         \
       } else {                                                               \
         for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {       \
           if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {                     \
             if (pChild->WndHitTest(pChild->ParentToChild(point))) {          \
               return pChild->mouse_method_name(pChild->ParentToChild(point), \
                                                nFlag);                       \
             }                                                                \
           }                                                                  \
         }                                                                    \
         if (WndHitTest(point))                                               \
           SetCursor();                                                       \
       }                                                                      \
     }                                                                        \
-    return FALSE;                                                            \
+    return false;                                                            \
   }
 
 PWL_IMPLEMENT_KEY_METHOD(OnKeyDown)
 PWL_IMPLEMENT_KEY_METHOD(OnKeyUp)
 PWL_IMPLEMENT_KEY_METHOD(OnChar)
 
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDblClk)
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDblClk)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
 
-FX_BOOL CPWL_Wnd::OnMouseWheel(short zDelta,
-                               const CFX_FloatPoint& point,
-                               uint32_t nFlag) {
+bool CPWL_Wnd::OnMouseWheel(short zDelta,
+                            const CFX_FloatPoint& point,
+                            uint32_t nFlag) {
   if (IsValid() && IsVisible() && IsEnabled()) {
     SetCursor();
     if (IsWndCaptureKeyboard(this)) {
       for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
         if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
           if (IsWndCaptureKeyboard(pChild)) {
             return pChild->OnMouseWheel(zDelta, pChild->ParentToChild(point),
                                         nFlag);
           }
         }
       }
     }
   }
-  return FALSE;
+  return false;
 }
 
 void CPWL_Wnd::AddChild(CPWL_Wnd* pWnd) {
   m_aChildren.Add(pWnd);
 }
 
 void CPWL_Wnd::RemoveChild(CPWL_Wnd* pWnd) {
   for (int32_t i = m_aChildren.GetSize() - 1; i >= 0; i--) {
     if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
       if (pChild == pWnd) {
@@ skipping 13 matching lines @@
       AddChild(pWnd);
       break;
     case PNM_REMOVECHILD:
       RemoveChild(pWnd);
       break;
     default:
       break;
   }
 }
 
-FX_BOOL CPWL_Wnd::IsValid() const {
+bool CPWL_Wnd::IsValid() const {
   return m_bCreated;
 }
 
 const PWL_CREATEPARAM& CPWL_Wnd::GetCreationParam() const {
   return m_sPrivateParam;
 }
 
 CPWL_Wnd* CPWL_Wnd::GetParentWindow() const {
   return m_sPrivateParam.pParentWnd;
 }
@@ skipping 12 matching lines @@
   rcClient.Normalize();
   return rcWindow.Contains(rcClient) ? rcClient : CFX_FloatRect();
 }
 
 CFX_FloatPoint CPWL_Wnd::GetCenterPoint() const {
   CFX_FloatRect rcClient = GetClientRect();
   return CFX_FloatPoint((rcClient.left + rcClient.right) * 0.5f,
                         (rcClient.top + rcClient.bottom) * 0.5f);
 }
 
-FX_BOOL CPWL_Wnd::HasFlag(uint32_t dwFlags) const {
+bool CPWL_Wnd::HasFlag(uint32_t dwFlags) const {
   return (m_sPrivateParam.dwFlags & dwFlags) != 0;
 }
 
 void CPWL_Wnd::RemoveFlag(uint32_t dwFlags) {
   m_sPrivateParam.dwFlags &= ~dwFlags;
 }
 
 void CPWL_Wnd::AddFlag(uint32_t dwFlags) {
   m_sPrivateParam.dwFlags |= dwFlags;
 }
@@ skipping 112 matching lines @@
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl()) {
     if (pMsgCtrl->IsWndCaptureKeyboard(this))
       pMsgCtrl->KillFocus();
   }
 }
 
 void CPWL_Wnd::OnSetFocus() {}
 
 void CPWL_Wnd::OnKillFocus() {}
 
-FX_BOOL CPWL_Wnd::WndHitTest(const CFX_FloatPoint& point) const {
+bool CPWL_Wnd::WndHitTest(const CFX_FloatPoint& point) const {
   return IsValid() && IsVisible() && GetWindowRect().Contains(point.x, point.y);
 }
 
-FX_BOOL CPWL_Wnd::ClientHitTest(const CFX_FloatPoint& point) const {
+bool CPWL_Wnd::ClientHitTest(const CFX_FloatPoint& point) const {
   return IsValid() && IsVisible() && GetClientRect().Contains(point.x, point.y);
 }
 
 const CPWL_Wnd* CPWL_Wnd::GetRootWnd() const {
   if (m_sPrivateParam.pParentWnd)
     return m_sPrivateParam.pParentWnd->GetRootWnd();
 
   return this;
 }
 
-void CPWL_Wnd::SetVisible(FX_BOOL bVisible) {
+void CPWL_Wnd::SetVisible(bool bVisible) {
   if (IsValid()) {
     for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
       if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
         pChild->SetVisible(bVisible);
       }
     }
 
     if (bVisible != m_bVisible) {
       m_bVisible = bVisible;
       RePosChildWnd();
       InvalidateRect();
     }
   }
 }
 
 void CPWL_Wnd::SetClipRect(const CFX_FloatRect& rect) {
   m_rcClip = rect;
   m_rcClip.Normalize();
 }
 
 const CFX_FloatRect& CPWL_Wnd::GetClipRect() const {
   return m_rcClip;
 }
 
-FX_BOOL CPWL_Wnd::IsReadOnly() const {
+bool CPWL_Wnd::IsReadOnly() const {
   return HasFlag(PWS_READONLY);
 }
 
 void CPWL_Wnd::RePosChildWnd() {
   CFX_FloatRect rcContent = CPWL_Utils::DeflateRect(
       GetWindowRect(), (FX_FLOAT)(GetBorderWidth() + GetInnerBorderWidth()));
 
   CPWL_ScrollBar* pVSB = GetVScrollBar();
 
   CFX_FloatRect rcVScroll =
       CFX_FloatRect(rcContent.right - PWL_SCROLLBAR_WIDTH, rcContent.bottom,
                     rcContent.right - 1.0f, rcContent.top);
 
   if (pVSB)
-    pVSB->Move(rcVScroll, TRUE, FALSE);
+    pVSB->Move(rcVScroll, true, false);
 }
 
 void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM& cp) {}
 
 void CPWL_Wnd::SetCursor() {
   if (IsValid()) {
     if (CFX_SystemHandler* pSH = GetSystemHandler()) {
       int32_t nCursorType = GetCreationParam().eCursorType;
       pSH->SetCursor(nCursorType);
     }
   }
 }
 
 void CPWL_Wnd::CreateMsgControl() {
   if (!m_sPrivateParam.pMsgControl)
     m_sPrivateParam.pMsgControl = new CPWL_MsgControl(this);
 }
 
 void CPWL_Wnd::DestroyMsgControl() {
   if (CPWL_MsgControl* pMsgControl = GetMsgControl())
     if (pMsgControl->IsWndCreated(this))
       delete pMsgControl;
 }
 
 CPWL_MsgControl* CPWL_Wnd::GetMsgControl() const {
   return m_sPrivateParam.pMsgControl;
 }
 
-FX_BOOL CPWL_Wnd::IsCaptureMouse() const {
+bool CPWL_Wnd::IsCaptureMouse() const {
   return IsWndCaptureMouse(this);
 }
 
-FX_BOOL CPWL_Wnd::IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
+bool CPWL_Wnd::IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
   if (CPWL_MsgControl* pCtrl = GetMsgControl())
     return pCtrl->IsWndCaptureMouse(pWnd);
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPWL_Wnd::IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
+bool CPWL_Wnd::IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
   if (CPWL_MsgControl* pCtrl = GetMsgControl())
     return pCtrl->IsWndCaptureKeyboard(pWnd);
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPWL_Wnd::IsFocused() const {
+bool CPWL_Wnd::IsFocused() const {
   if (CPWL_MsgControl* pCtrl = GetMsgControl())
     return pCtrl->IsMainCaptureKeyboard(this);
 
-  return FALSE;
+  return false;
 }
 
 CFX_FloatRect CPWL_Wnd::GetFocusRect() const {
   return CPWL_Utils::InflateRect(GetWindowRect(), 1);
 }
 
 FX_FLOAT CPWL_Wnd::GetFontSize() const {
   return m_sPrivateParam.fFontSize;
 }
 
@@ skipping 160 matching lines @@
 }
 
 const CPWL_Wnd* CPWL_Wnd::GetFocused() const {
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl()) {
     return pMsgCtrl->m_pMainKeyboardWnd;
   }
 
   return nullptr;
 }
 
-void CPWL_Wnd::EnableWindow(FX_BOOL bEnable) {
+void CPWL_Wnd::EnableWindow(bool bEnable) {
   if (m_bEnabled != bEnable) {
     for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
       if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
         pChild->EnableWindow(bEnable);
       }
     }
 
     m_bEnabled = bEnable;
 
     if (bEnable)
       OnEnabled();
     else
       OnDisabled();
   }
 }
 
-FX_BOOL CPWL_Wnd::IsEnabled() {
+bool CPWL_Wnd::IsEnabled() {
   return m_bEnabled;
 }
 
 void CPWL_Wnd::OnEnabled() {}
 
 void CPWL_Wnd::OnDisabled() {}
 
-FX_BOOL CPWL_Wnd::IsCTRLpressed(uint32_t nFlag) const {
+bool CPWL_Wnd::IsCTRLpressed(uint32_t nFlag) const {
   if (CFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsCTRLKeyDown(nFlag);
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPWL_Wnd::IsSHIFTpressed(uint32_t nFlag) const {
+bool CPWL_Wnd::IsSHIFTpressed(uint32_t nFlag) const {
   if (CFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsSHIFTKeyDown(nFlag);
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPWL_Wnd::IsALTpressed(uint32_t nFlag) const {
+bool CPWL_Wnd::IsALTpressed(uint32_t nFlag) const {
   if (CFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsALTKeyDown(nFlag);
   }
 
-  return FALSE;
+  return false;
 }