FX_BOOL considered harmful.

fpdfsdk/src/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 "../../include/pdfwindow/PDFWindow.h"
 #include "../../include/pdfwindow/PWL_Wnd.h"
@@ skipping 105 matching lines @@
         }
 
         void Default()
         {
                 m_aMousePath.RemoveAll();
                 m_aKeyboardPath.RemoveAll();
                 m_pMainMouseWnd = NULL;
                 m_pMainKeyboardWnd = NULL;
         }
 
-        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;
 
@@ skipping 48 matching lines @@
         CPWL_Wnd*                                               m_pMainMouseWnd;
         CPWL_Wnd*                                               m_pMainKeyboardWnd;
 };
 
 /* --------------------------- CPWL_Wnd ---------------------------- */
 
 CPWL_Wnd::CPWL_Wnd() :
         m_pVScrollBar(NULL),
         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())
@@ skipping 17 matching lines @@
                 ccp.mtChild = CPDF_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()
 {
 }
@@ skipping 15 matching lines @@
                         if (CPWL_Wnd * pChild = m_aChildren[i])
                         {
                                 pChild->Destroy();
                                 delete pChild;
                                 pChild = NULL;
                         }
                 }
 
                 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 = NULL;
 }
 
-void CPWL_Wnd::Move(const CPDF_Rect & rcNew, FX_BOOL bReset,FX_BOOL bRefresh)
+void CPWL_Wnd::Move(const CPDF_Rect & rcNew, bool bReset,bool bRefresh)
 {
         if (IsValid())
         {
                 CPDF_Rect 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)
@@ skipping 155 matching lines @@
                 {
                         if (FX_HWND hWnd = GetAttachedHWnd())
                         {
                                 pSH->InvalidateRect(hWnd, rcWin);
                         }
                 }
         }
 }
 
 #define PWL_IMPLEMENT_KEY_METHOD(key_method_name)\
-FX_BOOL CPWL_Wnd::key_method_name(FX_WORD nChar, FX_DWORD nFlag)\
+bool CPWL_Wnd::key_method_name(FX_WORD nChar, FX_DWORD 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 CPDF_Point & point, FX_DWORD nFlag)\
+bool CPWL_Wnd::mouse_method_name(const CPDF_Point & point, FX_DWORD 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))\
@@ skipping 13 matching lines @@
                                         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 CPDF_Point & point, FX_DWORD nFlag)
+bool    CPWL_Wnd::OnMouseWheel(short zDelta, const CPDF_Point & point, FX_DWORD 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 --)
@@ skipping 17 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;
 }
 
 PWL_CREATEPARAM CPWL_Wnd::GetCreationParam() const
 {
         return m_sPrivateParam;
 }
 
 CPWL_Wnd* CPWL_Wnd::GetParentWindow() const
@@ skipping 38 matching lines @@
 CPDF_Rect CPWL_Wnd::GetClientCenterSquare() const
 {
         return CPWL_Utils::GetCenterSquare(GetClientRect());
 }
 
 CPDF_Rect CPWL_Wnd::GetWindowCenterSquare() const
 {
         return CPWL_Utils::GetCenterSquare(CPWL_Utils::DeflateRect(GetWindowRect(),0.1f));
 }
 
-FX_BOOL CPWL_Wnd::HasFlag(FX_DWORD dwFlags) const
+bool CPWL_Wnd::HasFlag(FX_DWORD dwFlags) const
 {
         return (m_sPrivateParam.dwFlags & dwFlags) != 0;
 }
 
 void CPWL_Wnd::RemoveFlag(FX_DWORD dwFlags)
 {
         m_sPrivateParam.dwFlags &= ~dwFlags;
 }
 
 void CPWL_Wnd::AddFlag(FX_DWORD dwFlags)
@@ skipping 167 matching lines @@
 }
 
 void CPWL_Wnd::OnSetFocus()
 {
 }
 
 void CPWL_Wnd::OnKillFocus()
 {
 }
 
-FX_BOOL CPWL_Wnd::WndHitTest(const CPDF_Point & point) const
+bool    CPWL_Wnd::WndHitTest(const CPDF_Point & point) const
 {
         return IsValid() && IsVisible() && GetWindowRect().Contains(point.x,point.y);
 }
 
-FX_BOOL CPWL_Wnd::ClientHitTest(const CPDF_Point & point) const
+bool CPWL_Wnd::ClientHitTest(const CPDF_Point & 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();
         else
                 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);
                         }
                 }
@@ skipping 11 matching lines @@
 {
         m_rcClip = rect;
         m_rcClip.Normalize();
 }
 
 CPDF_Rect 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()
 {
         CPDF_Rect rcContent = CPWL_Utils::DeflateRect(GetWindowRect(),(FX_FLOAT)(GetBorderWidth()+GetInnerBorderWidth()));
 
         CPWL_ScrollBar * pVSB = GetVScrollBar();
 
         CPDF_Rect rcVScroll = CPDF_Rect(rcContent.right - PWL_SCROLLBAR_WIDTH,
                                                         rcContent.bottom,
                                                         rcContent.right-1.0f,
                                                         rcContent.top);
 
-        if (pVSB) pVSB->Move(rcVScroll,TRUE,FALSE);
+        if (pVSB) pVSB->Move(rcVScroll,true,false);
 }
 
 void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM & cp)
 {
 }
 
 void CPWL_Wnd::SetCursor()
 {
         if (IsValid())
         {
@@ skipping 16 matching lines @@
         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;
 }
 
 CPDF_Rect CPWL_Wnd::GetFocusRect() const
 {
         return CPWL_Utils::InflateRect(GetWindowRect(),1);
 }
 
 FX_FLOAT CPWL_Wnd::GetFontSize() const
 {
         return m_sPrivateParam.fFontSize;
@@ skipping 212 matching lines @@
 const CPWL_Wnd* CPWL_Wnd::GetFocused() const
 {
         if (CPWL_MsgControl * pMsgCtrl = GetMsgControl())
         {
                 return pMsgCtrl->m_pMainKeyboardWnd;
         }
 
         return NULL;
 }
 
-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(FX_DWORD nFlag) const
+bool CPWL_Wnd::IsCTRLpressed(FX_DWORD nFlag) const
 {
         if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
         {
                 return pSystemHandler->IsCTRLKeyDown(nFlag);
         }
 
-        return FALSE;
+        return false;
 }
 
-FX_BOOL CPWL_Wnd::IsSHIFTpressed(FX_DWORD nFlag) const
+bool    CPWL_Wnd::IsSHIFTpressed(FX_DWORD nFlag) const
 {
         if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
         {
                 return pSystemHandler->IsSHIFTKeyDown(nFlag);
         }
 
-        return FALSE;
+        return false;
 }
 
-FX_BOOL CPWL_Wnd::IsALTpressed(FX_DWORD nFlag) const
+bool    CPWL_Wnd::IsALTpressed(FX_DWORD nFlag) const
 {
         if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
         {
                 return pSystemHandler->IsALTKeyDown(nFlag);
         }
 
-        return FALSE;
+        return false;
 }
 
-FX_BOOL CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const
+bool    CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const
 {
         if (IFX_SystemHandler* pSystemHandler = GetSystemHandler())
         {
                 return pSystemHandler->IsINSERTKeyDown(nFlag);
         }
 
-        return FALSE;
+        return false;
 }