Remove FX_BOOL from fpdfsdk.

fpdfsdk/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 "fpdfsdk/pdfwindow/PWL_ScrollBar.h"
 
 #include "core/fxge/cfx_pathdata.h"
 #include "core/fxge/cfx_renderdevice.h"
@@ skipping 16 matching lines @@
 void PWL_FLOATRANGE::Set(FX_FLOAT min, FX_FLOAT max) {
   if (min > max) {
     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;
 }
 
 PWL_SCROLL_PRIVATEDATA::PWL_SCROLL_PRIVATEDATA() {
   Default();
@@ skipping 21 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() {
   if (!SetPos(fScrollPos - fSmallStep))
     SetPos(ScrollRange.fMin);
 }
 
 void PWL_SCROLL_PRIVATEDATA::AddBig() {
   if (!SetPos(fScrollPos + fBigStep))
     SetPos(ScrollRange.fMax);
 }
 
 void PWL_SCROLL_PRIVATEDATA::SubBig() {
   if (!SetPos(fScrollPos - fBigStep))
     SetPos(ScrollRange.fMin);
 }
 
 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";
 }
 
 void CPWL_SBButton::OnCreate(PWL_CREATEPARAM& cp) {
   cp.eCursorType = FXCT_ARROW;
@@ skipping 193 matching lines @@
           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,
+            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 24 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,
+            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 147 matching lines @@
         } break;
         default:
           break;
       }
       break;
     default:
       break;
   }
 }
 
-FX_BOOL CPWL_SBButton::OnLButtonDown(const CFX_FloatPoint& point,
-                                     uint32_t nFlag) {
+bool CPWL_SBButton::OnLButtonDown(const CFX_FloatPoint& point, uint32_t 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 CFX_FloatPoint& point,
-                                   uint32_t nFlag) {
+bool CPWL_SBButton::OnLButtonUp(const CFX_FloatPoint& point, uint32_t 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 CFX_FloatPoint& point,
-                                   uint32_t nFlag) {
+bool CPWL_SBButton::OnMouseMove(const CFX_FloatPoint& point, uint32_t nFlag) {
   CPWL_Wnd::OnMouseMove(point, nFlag);
 
   if (CPWL_Wnd* pParent = GetParentWindow()) {
     pParent->OnNotify(this, PNM_MOUSEMOVE, 0, (intptr_t)&point);
   }
 
-  return TRUE;
+  return true;
 }
 
 CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType)
     : m_sbType(sbType),
       m_pMinButton(nullptr),
       m_pMaxButton(nullptr),
       m_pPosButton(nullptr),
-      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";
 }
 
 void CPWL_ScrollBar::OnCreate(PWL_CREATEPARAM& cp) {
   cp.eCursorType = FXCT_ARROW;
 }
@@ skipping 18 matching lines @@
         fBWidth = (rcClient.right - rcClient.left -
                    PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) /
                   2;
 
         if (fBWidth > 0) {
           rcMinButton = CFX_FloatRect(rcClient.left, rcClient.bottom,
                                       rcClient.left + fBWidth, rcClient.top);
           rcMaxButton = CFX_FloatRect(rcClient.right - fBWidth, rcClient.bottom,
                                       rcClient.right, rcClient.top);
         } else {
-          SetVisible(FALSE);
+          SetVisible(false);
         }
       }
       break;
     case SBT_VSCROLL:
       if (IsFloatBigger(rcClient.top - rcClient.bottom,
                         PWL_SCROLLBAR_BUTTON_WIDTH * 2 +
                             PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2)) {
         rcMinButton = CFX_FloatRect(rcClient.left,
                                     rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH,
                                     rcClient.right, rcClient.top);
         rcMaxButton =
             CFX_FloatRect(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 = CFX_FloatRect(rcClient.left, rcClient.top - fBWidth,
                                       rcClient.right, rcClient.top);
           rcMaxButton =
               CFX_FloatRect(rcClient.left, rcClient.bottom, rcClient.right,
                             rcClient.bottom + fBWidth);
         } else {
-          SetVisible(FALSE);
+          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) {
   CFX_FloatRect rectWnd = GetWindowRect();
 
   if (IsVisible() && !rectWnd.IsEmpty()) {
     CFX_ByteTextBuf sButton;
 
     sButton << "q\n";
     sButton << "0 w\n"
-            << CPWL_Utils::GetColorAppStream(GetBackgroundColor(), TRUE)
+            << CPWL_Utils::GetColorAppStream(GetBackgroundColor(), true)
                    .AsStringC();
     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,
@@ skipping 11 matching lines @@
         ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
 
     CPWL_Utils::DrawStrokeLine(
         pDevice, pUser2Device,
         CFX_FloatPoint(rectWnd.right - 2.0f, rectWnd.top - 2.0f),
         CFX_FloatPoint(rectWnd.right - 2.0f, rectWnd.bottom + 2.0f),
         ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
   }
 }
 
-FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CFX_FloatPoint& point,
-                                      uint32_t nFlag) {
+bool CPWL_ScrollBar::OnLButtonDown(const CFX_FloatPoint& point,
+                                   uint32_t nFlag) {
   CPWL_Wnd::OnLButtonDown(point, nFlag);
 
   if (HasFlag(PWS_AUTOTRANSPARENT)) {
     if (GetTransparency() != 255) {
       SetTransparency(255);
       InvalidateRect();
     }
   }
 
   CFX_FloatRect rcMinArea, rcMaxArea;
@@ skipping 20 matching lines @@
                                   rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH,
                                   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 CFX_FloatPoint& point,
-                                    uint32_t nFlag) {
+bool CPWL_ScrollBar::OnLButtonUp(const CFX_FloatPoint& point, uint32_t 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,
                               uint32_t msg,
                               intptr_t wParam,
                               intptr_t lParam) {
   CPWL_Wnd::OnNotify(pWnd, msg, wParam, lParam);
 
   switch (msg) {
     case PNM_LBUTTONDOWN:
@@ skipping 75 matching lines @@
     m_pMinButton->Create(scp);
   }
 
   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_pMinButton);
   ASSERT(m_pMaxButton);
 
   if (m_pPosButton->IsVisible()) {
     CFX_FloatRect rcClient;
     CFX_FloatRect rcPosArea, rcPosButton;
 
     rcClient = GetClientRect();
     rcPosArea = GetScrollArea();
 
@@ skipping 27 matching lines @@
           fBottom = rcPosArea.bottom;
           fTop = fBottom + PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
         }
 
         rcPosButton =
             CFX_FloatRect(rcPosArea.left, fBottom, rcPosArea.right, fTop);
 
         break;
     }
 
-    m_pPosButton->Move(rcPosButton, TRUE, bRefresh);
+    m_pPosButton->Move(rcPosButton, true, bRefresh);
   }
 }
 
 void CPWL_ScrollBar::OnMinButtonLBDown(const CFX_FloatPoint& point) {
   m_sData.SubSmall();
-  MovePosButton(TRUE);
+  MovePosButton(true);
   NotifyScrollWindow();
 
-  m_bMinOrMax = TRUE;
+  m_bMinOrMax = true;
 
   EndTimer();
   BeginTimer(100);
 }
 
 void CPWL_ScrollBar::OnMinButtonLBUp(const CFX_FloatPoint& point) {}
 
 void CPWL_ScrollBar::OnMinButtonMouseMove(const CFX_FloatPoint& point) {}
 
 void CPWL_ScrollBar::OnMaxButtonLBDown(const CFX_FloatPoint& point) {
   m_sData.AddSmall();
-  MovePosButton(TRUE);
+  MovePosButton(true);
   NotifyScrollWindow();
 
-  m_bMinOrMax = FALSE;
+  m_bMinOrMax = false;
 
   EndTimer();
   BeginTimer(100);
 }
 
 void CPWL_ScrollBar::OnMaxButtonLBUp(const CFX_FloatPoint& point) {}
 
 void CPWL_ScrollBar::OnMaxButtonMouseMove(const CFX_FloatPoint& point) {}
 
 void CPWL_ScrollBar::OnPosButtonLBDown(const CFX_FloatPoint& point) {
-  m_bMouseDown = TRUE;
+  m_bMouseDown = true;
 
   if (m_pPosButton) {
     CFX_FloatRect 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 CFX_FloatPoint& point) {
   if (m_bMouseDown) {
     if (!m_bNotifyForever)
       NotifyScrollWindow();
   }
-  m_bMouseDown = FALSE;
+  m_bMouseDown = false;
 }
 
 void CPWL_ScrollBar::OnPosButtonMouseMove(const CFX_FloatPoint& point) {
   FX_FLOAT fOldScrollPos = m_sData.fScrollPos;
 
   FX_FLOAT fNewPos = 0;
 
   switch (m_sbType) {
     case SBT_HSCROLL:
       if (FXSYS_fabs(point.x - m_nOldPos) < 1)
@@ skipping 31 matching lines @@
         if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) {
           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()) {
     FX_FLOAT fPos;
@@ skipping 103 matching lines @@
 }
 
 void CPWL_ScrollBar::TimerProc() {
   PWL_SCROLL_PRIVATEDATA sTemp = m_sData;
   if (m_bMinOrMax)
     m_sData.SubSmall();
   else
     m_sData.AddSmall();
 
   if (sTemp != m_sData) {
-    MovePosButton(TRUE);
+    MovePosButton(true);
     NotifyScrollWindow();
   }
 }