Remove FX_BOOL from fpdfsdk.

fpdfsdk/cpdfsdk_pageview.cpp

 // Copyright 2016 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/cpdfsdk_pageview.h"
 
 #include <memory>
 #include <vector>
@@ skipping 18 matching lines @@
 #include "xfa/fxgraphics/cfx_graphics.h"
 #endif  // PDF_ENABLE_XFA
 
 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_FormFillEnvironment* pFormFillEnv,
                                    UnderlyingPageType* page)
     : m_page(page),
       m_pFormFillEnv(pFormFillEnv),
 #ifndef PDF_ENABLE_XFA
       m_bOwnsPage(false),
 #endif  // PDF_ENABLE_XFA
-      m_bEnterWidget(FALSE),
-      m_bExitWidget(FALSE),
-      m_bOnWidget(FALSE),
-      m_bValid(FALSE),
-      m_bLocked(FALSE),
+      m_bEnterWidget(false),
+      m_bExitWidget(false),
+      m_bOnWidget(false),
+      m_bValid(false),
+      m_bLocked(false),
       m_bBeingDestroyed(false) {
   CPDFSDK_InterForm* pInterForm = pFormFillEnv->GetInterForm();
   if (pInterForm) {
     CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
 #ifdef PDF_ENABLE_XFA
     if (page->GetPDFPage())
       pPDFInterForm->FixPageFields(page->GetPDFPage());
 #else   // PDF_ENABLE_XFA
     pPDFInterForm->FixPageFields(page);
 #endif  // PDF_ENABLE_XFA
@@ skipping 44 matching lines @@
     CFX_Graphics gs;
     gs.Create(pDevice);
     CFX_RectF rectClip;
     rectClip.Set(static_cast<FX_FLOAT>(pClip.left),
                  static_cast<FX_FLOAT>(pClip.top),
                  static_cast<FX_FLOAT>(pClip.Width()),
                  static_cast<FX_FLOAT>(pClip.Height()));
     gs.SetClipRect(rectClip);
     std::unique_ptr<CXFA_RenderContext> pRenderContext(new CXFA_RenderContext);
     CXFA_RenderOptions renderOptions;
-    renderOptions.m_bHighlight = TRUE;
+    renderOptions.m_bHighlight = true;
     CXFA_FFPageView* xfaView = pPage->GetXFAPageView();
     pRenderContext->StartRender(xfaView, &gs, *pUser2Device, renderOptions);
     pRenderContext->DoRender();
     pRenderContext->StopRender();
     CXFA_FFDocView* docView = xfaView->GetDocView();
     if (!docView)
       return;
     CPDFSDK_Annot* annot = GetFocusAnnot();
     if (!annot)
       return;
     // Render the focus widget
     docView->GetWidgetHandler()->RenderWidget(annot->GetXFAWidget(), &gs,
-                                              pUser2Device, FALSE);
+                                              pUser2Device, false);
     return;
   }
 #endif  // PDF_ENABLE_XFA
 
   // for pdf/static xfa.
   CPDFSDK_AnnotIterator annotIterator(this, true);
   while (CPDFSDK_Annot* pSDKAnnot = annotIterator.Next()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
         m_pFormFillEnv->GetAnnotHandlerMgr();
     pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device,
@@ skipping 48 matching lines @@
 
   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pFormFillEnv->GetAnnotHandlerMgr();
   pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
   if (!pSDKAnnot)
     return nullptr;
 
   m_SDKAnnotArray.push_back(pSDKAnnot);
   return pSDKAnnot;
 }
 
-FX_BOOL CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
+bool CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot) {
   if (!pAnnot)
-    return FALSE;
+    return false;
   CPDFXFA_Page* pPage = pAnnot->GetPDFXFAPage();
   if (!pPage || (pPage->GetContext()->GetDocType() != DOCTYPE_STATIC_XFA &&
                  pPage->GetContext()->GetDocType() != DOCTYPE_DYNAMIC_XFA))
-    return FALSE;
+    return false;
 
   if (GetFocusAnnot() == pAnnot)
     m_pFormFillEnv->KillFocusAnnot(0);
   CPDFSDK_AnnotHandlerMgr* pAnnotHandler = m_pFormFillEnv->GetAnnotHandlerMgr();
   if (pAnnotHandler)
     pAnnotHandler->ReleaseAnnot(pAnnot);
 
   auto it = std::find(m_SDKAnnotArray.begin(), m_SDKAnnotArray.end(), pAnnot);
   if (it != m_SDKAnnotArray.end())
     m_SDKAnnotArray.erase(it);
   if (m_pCaptureWidget.Get() == pAnnot)
     m_pCaptureWidget.Reset();
 
-  return TRUE;
+  return true;
 }
 #endif  // PDF_ENABLE_XFA
 
 CPDF_Document* CPDFSDK_PageView::GetPDFDocument() {
   if (m_page) {
 #ifdef PDF_ENABLE_XFA
     return m_page->GetContext()->GetPDFDoc();
 #else   // PDF_ENABLE_XFA
     return m_page->m_pDocument;
 #endif  // PDF_ENABLE_XFA
@@ skipping 23 matching lines @@
     return nullptr;
 
   for (CPDFSDK_Annot* pAnnot : m_SDKAnnotArray) {
     if (pAnnot->GetXFAWidget() == hWidget)
       return pAnnot;
   }
   return nullptr;
 }
 #endif  // PDF_ENABLE_XFA
 
-FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CFX_FloatPoint& point,
-                                        uint32_t nFlag) {
+bool CPDFSDK_PageView::OnLButtonDown(const CFX_FloatPoint& point,
+                                     uint32_t nFlag) {
   CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pAnnot) {
     m_pFormFillEnv->KillFocusAnnot(nFlag);
-    return FALSE;
+    return false;
   }
 
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
   if (!pAnnotHandlerMgr->Annot_OnLButtonDown(this, &pAnnot, nFlag, point))
-    return FALSE;
+    return false;
 
   if (!pAnnot)
-    return FALSE;
+    return false;
 
   m_pFormFillEnv->SetFocusAnnot(&pAnnot);
-  return TRUE;
+  return true;
 }
 
 #ifdef PDF_ENABLE_XFA
-FX_BOOL CPDFSDK_PageView::OnRButtonDown(const CFX_FloatPoint& point,
-                                        uint32_t nFlag) {
+bool CPDFSDK_PageView::OnRButtonDown(const CFX_FloatPoint& point,
+                                     uint32_t nFlag) {
   CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pAnnot)
-    return FALSE;
+    return false;
 
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
-  FX_BOOL ok =
-      pAnnotHandlerMgr->Annot_OnRButtonDown(this, &pAnnot, nFlag, point);
+  bool ok = pAnnotHandlerMgr->Annot_OnRButtonDown(this, &pAnnot, nFlag, point);
   if (!pAnnot)
-    return FALSE;
+    return false;
 
   if (ok)
     m_pFormFillEnv->SetFocusAnnot(&pAnnot);
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDFSDK_PageView::OnRButtonUp(const CFX_FloatPoint& point,
-                                      uint32_t nFlag) {
+bool CPDFSDK_PageView::OnRButtonUp(const CFX_FloatPoint& point,
+                                   uint32_t nFlag) {
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pFXAnnot)
-    return FALSE;
+    return false;
 
   if (pAnnotHandlerMgr->Annot_OnRButtonUp(this, &pFXAnnot, nFlag, point))
     m_pFormFillEnv->SetFocusAnnot(&pFXAnnot);
 
-  return TRUE;
+  return true;
 }
 #endif  // PDF_ENABLE_XFA
 
-FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CFX_FloatPoint& point,
-                                      uint32_t nFlag) {
+bool CPDFSDK_PageView::OnLButtonUp(const CFX_FloatPoint& point,
+                                   uint32_t nFlag) {
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXWidgetAtPoint(point.x, point.y));
   CPDFSDK_Annot::ObservedPtr pFocusAnnot(GetFocusAnnot());
   if (pFocusAnnot && pFocusAnnot != pFXAnnot) {
     // Last focus Annot gets a chance to handle the event.
     if (pAnnotHandlerMgr->Annot_OnLButtonUp(this, &pFocusAnnot, nFlag, point))
-      return TRUE;
+      return true;
   }
   return pFXAnnot &&
          pAnnotHandlerMgr->Annot_OnLButtonUp(this, &pFXAnnot, nFlag, point);
 }
 
-FX_BOOL CPDFSDK_PageView::OnMouseMove(const CFX_FloatPoint& point, int nFlag) {
+bool CPDFSDK_PageView::OnMouseMove(const CFX_FloatPoint& point, int nFlag) {
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
   CPDFSDK_Annot::ObservedPtr pFXAnnot(GetFXAnnotAtPoint(point.x, point.y));
   if (pFXAnnot) {
     if (m_pCaptureWidget && m_pCaptureWidget != pFXAnnot) {
-      m_bExitWidget = TRUE;
-      m_bEnterWidget = FALSE;
+      m_bExitWidget = true;
+      m_bEnterWidget = false;
       pAnnotHandlerMgr->Annot_OnMouseExit(this, &m_pCaptureWidget, nFlag);
     }
     m_pCaptureWidget.Reset(pFXAnnot.Get());
-    m_bOnWidget = TRUE;
+    m_bOnWidget = true;
     if (!m_bEnterWidget) {
-      m_bEnterWidget = TRUE;
-      m_bExitWidget = FALSE;
+      m_bEnterWidget = true;
+      m_bExitWidget = false;
       pAnnotHandlerMgr->Annot_OnMouseEnter(this, &pFXAnnot, nFlag);
     }
     pAnnotHandlerMgr->Annot_OnMouseMove(this, &pFXAnnot, nFlag, point);
-    return TRUE;
+    return true;
   }
   if (m_bOnWidget) {
-    m_bOnWidget = FALSE;
-    m_bExitWidget = TRUE;
-    m_bEnterWidget = FALSE;
+    m_bOnWidget = false;
+    m_bExitWidget = true;
+    m_bEnterWidget = false;
     if (m_pCaptureWidget) {
       pAnnotHandlerMgr->Annot_OnMouseExit(this, &m_pCaptureWidget, nFlag);
       m_pCaptureWidget.Reset();
     }
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnMouseWheel(double deltaX,
-                                       double deltaY,
-                                       const CFX_FloatPoint& point,
-                                       int nFlag) {
+bool CPDFSDK_PageView::OnMouseWheel(double deltaX,
+                                    double deltaY,
+                                    const CFX_FloatPoint& point,
+                                    int nFlag) {
   CPDFSDK_Annot::ObservedPtr pAnnot(GetFXWidgetAtPoint(point.x, point.y));
   if (!pAnnot)
-    return FALSE;
+    return false;
 
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
   return pAnnotHandlerMgr->Annot_OnMouseWheel(this, &pAnnot, nFlag, (int)deltaY,
                                               point);
 }
 
-FX_BOOL CPDFSDK_PageView::OnChar(int nChar, uint32_t nFlag) {
+bool CPDFSDK_PageView::OnChar(int nChar, uint32_t nFlag) {
   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
         m_pFormFillEnv->GetAnnotHandlerMgr();
     return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
   }
 
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag) {
+bool CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag) {
   if (CPDFSDK_Annot* pAnnot = GetFocusAnnot()) {
     CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
         m_pFormFillEnv->GetAnnotHandlerMgr();
     return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
   }
-  return FALSE;
+  return false;
 }
 
-FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
-  return FALSE;
+bool CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag) {
+  return false;
 }
 
 void CPDFSDK_PageView::LoadFXAnnots() {
   CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr =
       m_pFormFillEnv->GetAnnotHandlerMgr();
 
-  SetLock(TRUE);
+  SetLock(true);
 
 #ifdef PDF_ENABLE_XFA
   CFX_RetainPtr<CPDFXFA_Page> protector(m_page);
   if (m_pFormFillEnv->GetXFAContext()->GetDocType() == DOCTYPE_DYNAMIC_XFA) {
     CXFA_FFPageView* pageView = m_page->GetXFAPageView();
     std::unique_ptr<IXFA_WidgetIterator> pWidgetHander(
         pageView->CreateWidgetIterator(
             XFA_TRAVERSEWAY_Form,
             XFA_WidgetStatus_Visible | XFA_WidgetStatus_Viewable));
     if (!pWidgetHander) {
-      SetLock(FALSE);
+      SetLock(false);
       return;
     }
 
     while (CXFA_FFWidget* pXFAAnnot = pWidgetHander->MoveToNext()) {
       CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pXFAAnnot, this);
       if (!pAnnot)
         continue;
       m_SDKAnnotArray.push_back(pAnnot);
       pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
     }
 
-    SetLock(FALSE);
+    SetLock(false);
     return;
   }
 #endif  // PDF_ENABLE_XFA
 
   CPDF_Page* pPage = GetPDFPage();
   ASSERT(pPage);
   bool bUpdateAP = CPDF_InterForm::IsUpdateAPEnabled();
   // Disable the default AP construction.
   CPDF_InterForm::SetUpdateAP(false);
   m_pAnnotList = pdfium::MakeUnique<CPDF_AnnotList>(pPage);
   CPDF_InterForm::SetUpdateAP(bUpdateAP);
 
   const size_t nCount = m_pAnnotList->Count();
   for (size_t i = 0; i < nCount; ++i) {
     CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
     CheckUnSupportAnnot(GetPDFDocument(), pPDFAnnot);
     CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
     if (!pAnnot)
       continue;
     m_SDKAnnotArray.push_back(pAnnot);
     pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
   }
 
-  SetLock(FALSE);
+  SetLock(false);
 }
 
 void CPDFSDK_PageView::UpdateRects(const std::vector<CFX_FloatRect>& rects) {
   for (const auto& rc : rects)
     m_pFormFillEnv->Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
 }
 
 void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot) {
   CFX_FloatRect rcWindow = pAnnot->GetRect();
   m_pFormFillEnv->Invalidate(m_page, rcWindow.left, rcWindow.top,
@@ skipping 43 matching lines @@
 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot() {
   CPDFSDK_Annot* pFocusAnnot = m_pFormFillEnv->GetFocusAnnot();
   return IsValidSDKAnnot(pFocusAnnot) ? pFocusAnnot : nullptr;
 }
 
 int CPDFSDK_PageView::GetPageIndexForStaticPDF() const {
   CPDF_Dictionary* pDict = GetPDFPage()->m_pFormDict;
   CPDF_Document* pDoc = m_pFormFillEnv->GetPDFDocument();
   return (pDoc && pDict) ? pDoc->GetPageIndex(pDict->GetObjNum()) : -1;
 }