FX_BOOL considered harmful.

fpdfsdk/src/pdfwindow/PWL_ScrollBar.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 "../../include/pdfwindow/PDFWindow.h"
 #include "../../include/pdfwindow/PWL_Wnd.h"
 #include "../../include/pdfwindow/PWL_ScrollBar.h"
 #include "../../include/pdfwindow/PWL_Utils.h"
@@ skipping 29 matching lines @@
                 fMin = max;
                 fMax = min;
         }
         else
         {
                 fMin = min;
                 fMax = max;
         }
 }
 
-FX_BOOL PWL_FLOATRANGE::In(FX_FLOAT x) const
+bool    PWL_FLOATRANGE::In(FX_FLOAT x) const
 {
         return (IsFloatBigger(x,fMin) || IsFloatEqual(x, fMin)) &&
                 (IsFloatSmaller(x, fMax) || IsFloatEqual(x, fMax));
 }
 
 FX_FLOAT PWL_FLOATRANGE::GetWidth() const
 {
         return fMax - fMin;
 }
 
@@ skipping 31 matching lines @@
 void PWL_SCROLL_PRIVATEDATA::SetSmallStep(FX_FLOAT step)
 {
         fSmallStep = step;
 }
 
 void PWL_SCROLL_PRIVATEDATA::SetBigStep(FX_FLOAT step)
 {
         fBigStep = step;
 }
 
-FX_BOOL PWL_SCROLL_PRIVATEDATA::SetPos(FX_FLOAT pos)
+bool PWL_SCROLL_PRIVATEDATA::SetPos(FX_FLOAT pos)
 {
         if (ScrollRange.In(pos))
         {
                 fScrollPos = pos;
-                return TRUE;
+                return true;
         }
-        return FALSE;
+        return false;
 }
 
 void PWL_SCROLL_PRIVATEDATA::AddSmall()
 {
         if (!SetPos(fScrollPos + fSmallStep))
                 SetPos(ScrollRange.fMax);
 }
 
 void PWL_SCROLL_PRIVATEDATA::SubSmall()
 {
@@ skipping 13 matching lines @@
                 SetPos(ScrollRange.fMin);
 }
 
 /* ------------------------------- CPWL_SBButton ------------------------------- */
 
 CPWL_SBButton::CPWL_SBButton(PWL_SCROLLBAR_TYPE eScrollBarType,PWL_SBBUTTON_TYPE eButtonType)
 {
         m_eScrollBarType = eScrollBarType;
         m_eSBButtonType = eButtonType;
 
-        m_bMouseDown = FALSE;
+        m_bMouseDown = false;
 }
 
 CPWL_SBButton::~CPWL_SBButton()
 {
 
 }
 
 CFX_ByteString CPWL_SBButton::GetClassName() const
 {
         return "CPWL_SBButton";
@@ skipping 198 matching lines @@
                                 //draw inner border
                                 rcDraw = CPWL_Utils::DeflateRect(rectWnd,0.5f);
                                 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
                                         ArgbEncode(nTransparancy,255,255,255),1.0f);
 
                                 //draw background
 
                                 rcDraw = CPWL_Utils::DeflateRect(rectWnd,1.0f);
 
                                 if (IsEnabled())
-                                        CPWL_Utils::DrawShadow(pDevice, pUser2Device, TRUE, FALSE, rcDraw, nTransparancy, 80, 220);
+                                        CPWL_Utils::DrawShadow(pDevice, pUser2Device, true, false, rcDraw, nTransparancy, 80, 220);
                                 else
                                         CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw, ArgbEncode(255,255,255,255));
 
                                 //draw arrow
 
                                 if (rectWnd.top - rectWnd.bottom > 6.0f )
                                 {
                                         FX_FLOAT fX = rectWnd.left + 1.5f;
                                         FX_FLOAT fY = rectWnd.bottom;
                                         CPDF_Point pts[7] = {
@@ skipping 22 matching lines @@
                                         ArgbEncode(nTransparancy,100,100,100),0.0f);
 
                                 //draw inner border
                                 rcDraw = CPWL_Utils::DeflateRect(rectWnd,0.5f);
                                 CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
                                         ArgbEncode(nTransparancy,255,255,255),1.0f);
 
                                 //draw background
                                 rcDraw = CPWL_Utils::DeflateRect(rectWnd,1.0f);
                                 if (IsEnabled())
-                                        CPWL_Utils::DrawShadow(pDevice, pUser2Device, TRUE, FALSE, rcDraw, nTransparancy, 80, 220);
+                                        CPWL_Utils::DrawShadow(pDevice, pUser2Device, true, false, rcDraw, nTransparancy, 80, 220);
                                 else
                                         CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw, ArgbEncode(255,255,255,255));
 
                                 //draw arrow
 
                                 if (rectWnd.top - rectWnd.bottom > 6.0f )
                                 {
                                         FX_FLOAT fX = rectWnd.left + 1.5f;
                                         FX_FLOAT fY = rectWnd.bottom;
 
@@ skipping 142 matching lines @@
                         break;
                 default:
                         break;
                 }
                 break;
         default:
                 break;
         }
 }
 
-FX_BOOL CPWL_SBButton::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag)
+bool CPWL_SBButton::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag)
 {
         CPWL_Wnd::OnLButtonDown(point,nFlag);
 
         if (CPWL_Wnd * pParent = GetParentWindow())
                 pParent->OnNotify(this,PNM_LBUTTONDOWN,0,(intptr_t)&point);
 
-        m_bMouseDown = TRUE;
+        m_bMouseDown = true;
         SetCapture();
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CPWL_SBButton::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag)
+bool CPWL_SBButton::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag)
 {
         CPWL_Wnd::OnLButtonUp(point,nFlag);
 
         if (CPWL_Wnd * pParent = GetParentWindow())
                 pParent->OnNotify(this,PNM_LBUTTONUP,0,(intptr_t)&point);
 
-        m_bMouseDown = FALSE;
+        m_bMouseDown = false;
         ReleaseCapture();
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CPWL_SBButton::OnMouseMove(const CPDF_Point & point, FX_DWORD nFlag)
+bool CPWL_SBButton::OnMouseMove(const CPDF_Point & point, FX_DWORD nFlag)
 {
         CPWL_Wnd::OnMouseMove(point,nFlag);
 
         if (CPWL_Wnd * pParent = GetParentWindow())
         {
                 pParent->OnNotify(this,PNM_MOUSEMOVE,0,(intptr_t)&point);
 
                 /*
                 if (m_bMouseDown && (m_eSBButtonType == PSBT_MIN || m_eSBButtonType == PSBT_MAX))
                 {
                         if (!pParent->OnNotify(this,PNM_LBUTTONDOWN,nFlags,(intptr_t)&point))
-                                return FALSE;
+                                return false;
                 }
                 */
         }
 
-        return TRUE;
+        return true;
 }
 
 /* ------------------------------- CPWL_ScrollBar ---------------------------------- */
 
 CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType):
         m_sbType(sbType),
         m_pMinButton(NULL),
         m_pMaxButton(NULL),
         m_pPosButton(NULL),
-        m_bMouseDown(FALSE),
-        m_bMinOrMax(FALSE),
-        m_bNotifyForever(TRUE)
+        m_bMouseDown(false),
+        m_bMinOrMax(false),
+        m_bNotifyForever(true)
 {
 }
 
 CPWL_ScrollBar::~CPWL_ScrollBar()
 {
 }
 
 CFX_ByteString CPWL_ScrollBar::GetClassName() const
 {
         return "CPWL_ScrollBar";
@@ skipping 24 matching lines @@
                 {
                         fBWidth = (rcClient.right - rcClient.left - PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) / 2;
 
                         if (fBWidth > 0)
                         {
                                 rcMinButton = CPDF_Rect(rcClient.left,rcClient.bottom,
                                         rcClient.left + fBWidth,rcClient.top);
                                 rcMaxButton = CPDF_Rect(rcClient.right - fBWidth,rcClient.bottom,
                                         rcClient.right,rcClient.top);
                         }
-                        else SetVisible(FALSE);
+                        else SetVisible(false);
                 }
                 break;
         case SBT_VSCROLL:
                 if (IsFloatBigger(rcClient.top - rcClient.bottom, PWL_SCROLLBAR_BUTTON_WIDTH * 2 + PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2))
                 {
                         rcMinButton = CPDF_Rect(rcClient.left,rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH,
                                 rcClient.right,rcClient.top);
                         rcMaxButton = CPDF_Rect(rcClient.left,rcClient.bottom,
                                 rcClient.right,rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH);
                 }
                 else
                 {
                         fBWidth = (rcClient.top - rcClient.bottom - PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) / 2;
 
                         if (IsFloatBigger(fBWidth, 0))
                         {
                                 rcMinButton = CPDF_Rect(rcClient.left,rcClient.top - fBWidth,
                                         rcClient.right,rcClient.top);
                                 rcMaxButton = CPDF_Rect(rcClient.left,rcClient.bottom,
                                         rcClient.right,rcClient.bottom + fBWidth);
                         }
-                        else SetVisible(FALSE);
+                        else SetVisible(false);
                 }
                 break;
         }
 
     if (m_pMinButton)
-        m_pMinButton->Move(rcMinButton, TRUE, FALSE);
+        m_pMinButton->Move(rcMinButton, true, false);
     if (m_pMaxButton)
-        m_pMaxButton->Move(rcMaxButton, TRUE, FALSE);
-    MovePosButton(FALSE);
+        m_pMaxButton->Move(rcMaxButton, true, false);
+    MovePosButton(false);
 }
 
 void CPWL_ScrollBar::GetThisAppearanceStream(CFX_ByteTextBuf & sAppStream)
 {
         CPDF_Rect rectWnd = GetWindowRect();
 
         if (IsVisible() && !rectWnd.IsEmpty())
         {
                 CFX_ByteTextBuf sButton;
 
                 sButton << "q\n";
-                sButton << "0 w\n" << CPWL_Utils::GetColorAppStream(GetBackgroundColor(),TRUE);
+                sButton << "0 w\n" << CPWL_Utils::GetColorAppStream(GetBackgroundColor(),true);
                 sButton << rectWnd.left << " " << rectWnd.bottom << " "
                                 << rectWnd.right - rectWnd.left << " " << rectWnd.top - rectWnd.bottom << " re b Q\n";
 
                 sAppStream << sButton;
         }
 }
 
 void CPWL_ScrollBar::DrawThisAppearance(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device)
 {
         CPDF_Rect rectWnd = GetWindowRect();
 
         if (IsVisible() && !rectWnd.IsEmpty())
         {
                 CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rectWnd, GetBackgroundColor(), GetTransparency());
 
                 CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device,
                         CPDF_Point(rectWnd.left+2.0f,rectWnd.top-2.0f), CPDF_Point(rectWnd.left+2.0f,rectWnd.bottom+2.0f),
                         ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
 
                 CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device,
                         CPDF_Point(rectWnd.right-2.0f,rectWnd.top-2.0f), CPDF_Point(rectWnd.right-2.0f,rectWnd.bottom+2.0f),
                         ArgbEncode(GetTransparency(), 100, 100, 100),1.0f);
         }
 }
 
-FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag)
+bool CPWL_ScrollBar::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag)
 {
         CPWL_Wnd::OnLButtonDown(point,nFlag);
 
         if (HasFlag(PWS_AUTOTRANSPARENT))
         {
                 if (GetTransparency() != 255)
                 {
                         SetTransparency(255);
                         InvalidateRect();
                 }
@@ skipping 22 matching lines @@
                                                         rcClient.right,rcPosButton.bottom);
                         break;
                 }
 
                 rcMinArea.Normalize();
                 rcMaxArea.Normalize();
 
                 if (rcMinArea.Contains(point.x,point.y))
                 {
                         m_sData.SubBig();
-                        MovePosButton(TRUE);
+                        MovePosButton(true);
                         NotifyScrollWindow();
                 }
 
                 if (rcMaxArea.Contains(point.x,point.y))
                 {
                         m_sData.AddBig();
-                        MovePosButton(TRUE);
+                        MovePosButton(true);
                         NotifyScrollWindow();
                 }
         }
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CPWL_ScrollBar::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag)
+bool CPWL_ScrollBar::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag)
 {
         CPWL_Wnd::OnLButtonUp(point,nFlag);
 
         if (HasFlag(PWS_AUTOTRANSPARENT))
         {
                 if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY)
                 {
                         SetTransparency(PWL_SCROLLBAR_TRANSPARANCY);
                         InvalidateRect();
                 }
         }
 
         EndTimer();
-        m_bMouseDown = FALSE;
+        m_bMouseDown = false;
 
-        return TRUE;
+        return true;
 }
 
 void CPWL_ScrollBar::OnNotify(CPWL_Wnd* pWnd, FX_DWORD msg, intptr_t wParam, intptr_t lParam)
 {
         CPWL_Wnd::OnNotify(pWnd,msg,wParam,lParam);
 
         switch (msg)
         {
         case PNM_LBUTTONDOWN:
                 if (pWnd == m_pMinButton)
@@ skipping 93 matching lines @@
 
         if (!m_pMaxButton)
         {
                 m_pMaxButton = new CPWL_SBButton(m_sbType,PSBT_MAX);
                 m_pMaxButton->Create(scp);
         }
 
         if (!m_pPosButton)
         {
                 m_pPosButton = new CPWL_SBButton(m_sbType,PSBT_POS);
-                m_pPosButton->SetVisible(FALSE);
+                m_pPosButton->SetVisible(false);
                 m_pPosButton->Create(scp);
         }
 }
 
 FX_FLOAT CPWL_ScrollBar::GetScrollBarWidth() const
 {
         if (!IsVisible()) return 0;
 
         return PWL_SCROLLBAR_WIDTH;
 }
 
 void CPWL_ScrollBar::SetScrollRange(FX_FLOAT fMin,FX_FLOAT fMax,FX_FLOAT fClientWidth)
 {
         if (m_pPosButton)
         {
                 m_sData.SetScrollRange(fMin,fMax);
                 m_sData.SetClientWidth(fClientWidth);
 
                 if (IsFloatSmaller(m_sData.ScrollRange.GetWidth(), 0.0f))
                 {
-                        m_pPosButton->SetVisible(FALSE);
+                        m_pPosButton->SetVisible(false);
                 }
                 else
                 {
-                        m_pPosButton->SetVisible(TRUE);
-                        MovePosButton(TRUE);
+                        m_pPosButton->SetVisible(true);
+                        MovePosButton(true);
                 }
         }
 }
 
 void CPWL_ScrollBar::SetScrollPos(FX_FLOAT fPos)
 {
         FX_FLOAT fOldPos = m_sData.fScrollPos;
 
         m_sData.SetPos(fPos);
 
         if (!IsFloatEqual(m_sData.fScrollPos, fOldPos))
-                MovePosButton(TRUE);
+                MovePosButton(true);
 }
 
 void CPWL_ScrollBar::SetScrollStep(FX_FLOAT fBigStep,FX_FLOAT fSmallStep)
 {
         m_sData.SetBigStep(fBigStep);
         m_sData.SetSmallStep(fSmallStep);
 }
 
-void CPWL_ScrollBar::MovePosButton(FX_BOOL bRefresh)
+void CPWL_ScrollBar::MovePosButton(bool bRefresh)
 {
         ASSERT (m_pPosButton != NULL);
         ASSERT (m_pMinButton != NULL);
         ASSERT (m_pMaxButton != NULL);
 
         if (m_pPosButton->IsVisible())
         {
 
 
 
@@ skipping 41 matching lines @@
                         }
 
                         rcPosButton = CPDF_Rect(rcPosArea.left,
                                                                 fBottom,
                                                                 rcPosArea.right,
                                                                 fTop);
 
                         break;
                 }
 
-                m_pPosButton->Move(rcPosButton,TRUE,bRefresh);
+                m_pPosButton->Move(rcPosButton,true,bRefresh);
         }
 }
 
 void CPWL_ScrollBar::OnMinButtonLBDown(const CPDF_Point & point)
 {
         m_sData.SubSmall();
-        MovePosButton(TRUE);
+        MovePosButton(true);
         NotifyScrollWindow();
 
-        m_bMinOrMax = TRUE;
+        m_bMinOrMax = true;
 
         EndTimer();
         BeginTimer(100);
 }
 
 void CPWL_ScrollBar::OnMinButtonLBUp(const CPDF_Point & point)
 {
 }
 
 void CPWL_ScrollBar::OnMinButtonMouseMove(const CPDF_Point & point)
 {
 }
 
 void CPWL_ScrollBar::OnMaxButtonLBDown(const CPDF_Point & point)
 {
         m_sData.AddSmall();
-        MovePosButton(TRUE);
+        MovePosButton(true);
         NotifyScrollWindow();
 
-        m_bMinOrMax = FALSE;
+        m_bMinOrMax = false;
 
         EndTimer();
         BeginTimer(100);
 }
 
 void CPWL_ScrollBar::OnMaxButtonLBUp(const CPDF_Point & point)
 {
 }
 
 void CPWL_ScrollBar::OnMaxButtonMouseMove(const CPDF_Point & point)
 {
 }
 
 void CPWL_ScrollBar::OnPosButtonLBDown(const CPDF_Point & point)
 {
-        m_bMouseDown = TRUE;
+        m_bMouseDown = true;
 
         if (m_pPosButton)
         {
                 CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect();
 
                 switch(m_sbType)
                 {
                 case SBT_HSCROLL:
                         m_nOldPos = point.x;
                         m_fOldPosButton = rcPosButton.left;
                         break;
                 case SBT_VSCROLL:
                         m_nOldPos = point.y;
                         m_fOldPosButton = rcPosButton.top;
                         break;
                 }
         }
 }
 
 void CPWL_ScrollBar::OnPosButtonLBUp(const CPDF_Point & point)
 {
         if (m_bMouseDown)
         {
                 if (!m_bNotifyForever)
                         NotifyScrollWindow();
         }
-        m_bMouseDown = FALSE;
+        m_bMouseDown = false;
 }
 
 void CPWL_ScrollBar::OnPosButtonMouseMove(const CPDF_Point & point)
 {
         FX_FLOAT fOldScrollPos = m_sData.fScrollPos;
 
         FX_FLOAT fNewPos = 0;
 
         switch (m_sbType)
         {
@@ skipping 38 matching lines @@
                                 fNewPos = m_sData.ScrollRange.fMax;
                         }
 
                         m_sData.SetPos(fNewPos);
 
                         break;
                 }
 
                 if (!IsFloatEqual(fOldScrollPos, m_sData.fScrollPos))
                 {
-                        MovePosButton(TRUE);
+                        MovePosButton(true);
 
                         if (m_bNotifyForever)
                                 NotifyScrollWindow();
                 }
         }
 }
 
 void CPWL_ScrollBar::NotifyScrollWindow()
 {
         if (CPWL_Wnd * pParent = GetParentWindow())
@@ skipping 113 matching lines @@
 
 void CPWL_ScrollBar::TimerProc()
 {
         PWL_SCROLL_PRIVATEDATA sTemp = m_sData;
 
         if (m_bMinOrMax)m_sData.SubSmall();
         else m_sData.AddSmall();
 
         if (FXSYS_memcmp(&m_sData, &sTemp, sizeof(PWL_SCROLL_PRIVATEDATA)) != 0)
         {
-                MovePosButton(TRUE);
+                MovePosButton(true);
                 NotifyScrollWindow();
         }
 }