Remove FX_BOOL from xfa.

xfa/fwl/core/cfwl_widgetmgr.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 "xfa/fwl/core/cfwl_widgetmgr.h"
 
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_form.h"
 #include "xfa/fxfa/app/xfa_fwladapter.h"
 #include "xfa/fxfa/xfa_ffapp.h"
 
 namespace {
 
 const int kNeedRepaintHitPoints = 12;
 const int kNeedRepaintHitPiece = 3;
 
 struct FWL_NEEDREPAINTHITDATA {
   CFX_PointF hitPoint;
   bool bNotNeedRepaint;
   bool bNotContainByDirty;
 };
 
 }  // namespace
 
-FX_BOOL FWL_UseOffscreen(IFWL_Widget* pWidget) {
+bool FWL_UseOffscreen(IFWL_Widget* pWidget) {
 #if (_FX_OS_ == _FX_MACOSX_)
-  return FALSE;
+  return false;
 #else
   return !!(pWidget->GetStyles() & FWL_WGTSTYLE_Offscreen);
 #endif
 }
 
 CFWL_WidgetMgr::CFWL_WidgetMgr(CXFA_FFApp* pAdapterNative)
     : m_dwCapability(0),
       m_pDelegate(new CFWL_WidgetMgrDelegate(this)),
       m_pAdapter(pAdapterNative->GetWidgetMgr(m_pDelegate.get())) {
   ASSERT(m_pAdapter);
@@ skipping 60 matching lines @@
 IFWL_Widget* CFWL_WidgetMgr::GetSystemFormWidget(IFWL_Widget* pWidget) const {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   while (pItem) {
     if (IsAbleNative(pItem->pWidget))
       return pItem->pWidget;
     pItem = pItem->pParent;
   }
   return nullptr;
 }
 
-FX_BOOL CFWL_WidgetMgr::SetWidgetIndex(IFWL_Widget* pWidget, int32_t nIndex) {
+bool CFWL_WidgetMgr::SetWidgetIndex(IFWL_Widget* pWidget, int32_t nIndex) {
   CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
   if (!pItem)
-    return FALSE;
+    return false;
   if (!pItem->pParent)
-    return FALSE;
+    return false;
   CFWL_WidgetMgrItem* pChild = pItem->pParent->pChild;
   int32_t i = 0;
   while (pChild) {
     if (pChild == pItem) {
       if (i == nIndex) {
-        return TRUE;
+        return true;
       }
       if (pChild->pPrevious) {
         pChild->pPrevious->pNext = pChild->pNext;
       }
       if (pChild->pNext) {
         pChild->pNext->pPrevious = pChild->pPrevious;
       }
       if (pItem->pParent->pChild == pItem) {
         pItem->pParent->pChild = pItem->pNext;
       }
       pItem->pNext = nullptr;
       pItem->pPrevious = nullptr;
       break;
     }
     if (!pChild->pNext) {
       break;
     }
     pChild = pChild->pNext;
     ++i;
   }
   pChild = pItem->pParent->pChild;
   if (pChild) {
     if (nIndex < 0) {
       while (pChild->pNext) {
         pChild = pChild->pNext;
       }
       pChild->pNext = pItem;
       pItem->pPrevious = pChild;
       pItem->pNext = nullptr;
-      return TRUE;
+      return true;
     }
     i = 0;
     while (i < nIndex && pChild->pNext) {
       pChild = pChild->pNext;
       ++i;
     }
     if (!pChild->pNext) {
       pChild->pNext = pItem;
       pItem->pPrevious = pChild;
       pItem->pNext = nullptr;
-      return TRUE;
+      return true;
     }
     if (pChild->pPrevious) {
       pItem->pPrevious = pChild->pPrevious;
       pChild->pPrevious->pNext = pItem;
     }
     pChild->pPrevious = pItem;
     pItem->pNext = pChild;
     if (pItem->pParent->pChild == pChild) {
       pItem->pParent->pChild = pItem;
     }
   } else {
     pItem->pParent->pChild = pItem;
     pItem->pPrevious = nullptr;
     pItem->pNext = nullptr;
   }
-  return TRUE;
+  return true;
 }
 FWL_Error CFWL_WidgetMgr::RepaintWidget(IFWL_Widget* pWidget,
                                         const CFX_RectF* pRect) {
   if (!m_pAdapter)
     return FWL_Error::Indefinite;
   IFWL_Widget* pNative = pWidget;
   CFX_RectF rect(*pRect);
   if (IsFormDisabled()) {
     IFWL_Widget* pOuter = pWidget->GetOuter();
     while (pOuter) {
@@ skipping 115 matching lines @@
     if (pItem->pParent->pChild == pItem) {
       pItem->pParent->pChild = pItem->pNext;
     }
     pItem->pNext = nullptr;
     pItem->pPrevious = nullptr;
   }
   pItem->pParent = pParentItem;
   SetWidgetIndex(pChild, -1);
 }
 
-FX_BOOL CFWL_WidgetMgr::IsChild(IFWL_Widget* pChild, IFWL_Widget* pParent) {
+bool CFWL_WidgetMgr::IsChild(IFWL_Widget* pChild, IFWL_Widget* pParent) {
   IFWL_Widget* pTemp = pChild;
   do {
     if (pTemp == pParent)
-      return TRUE;
+      return true;
     pTemp = GetParentWidget(pTemp);
   } while (pTemp);
-  return FALSE;
+  return false;
 }
 
 FWL_Error CFWL_WidgetMgr::SetWidgetRect_Native(IFWL_Widget* pWidget,
                                                const CFX_RectF& rect) {
   if (FWL_UseOffscreen(pWidget)) {
     CFWL_WidgetMgrItem* pItem = GetWidgetMgrItem(pWidget);
     pItem->iRedrawCounter++;
     if (pItem->pOffscreen) {
       CFX_RenderDevice* pDevice = pItem->pOffscreen->GetRenderDevice();
       if (pDevice && pDevice->GetBitmap()) {
@@ skipping 44 matching lines @@
 
 void CFWL_WidgetMgr::NotifySizeChanged(IFWL_Widget* pForm,
                                        FX_FLOAT fx,
                                        FX_FLOAT fy) {
   if (FWL_UseOffscreen(pForm))
     GetWidgetMgrItem(pForm)->pOffscreen.reset();
 }
 
 IFWL_Widget* CFWL_WidgetMgr::nextTab(IFWL_Widget* parent,
                                      IFWL_Widget* focus,
-                                     FX_BOOL& bFind) {
+                                     bool& bFind) {
   CFWL_WidgetMgr* pMgr = parent->GetOwnerApp()->GetWidgetMgr();
   IFWL_Widget* child = pMgr->GetFirstChildWidget(parent);
   while (child) {
     if (focus == child)
-      bFind = TRUE;
+      bFind = true;
 
     if ((child->GetStyles() & FWL_WGTSTYLE_TabStop) &&
         (!focus || (focus != child && bFind))) {
       return child;
     }
     IFWL_Widget* bRet = nextTab(child, focus, bFind);
     if (bRet)
       return bRet;
 
     child = pMgr->GetNextSiblingWidget(child);
   }
   return nullptr;
 }
 
 int32_t CFWL_WidgetMgr::CountRadioButtonGroup(IFWL_Widget* pFirst) {
   int32_t iRet = 0;
   IFWL_Widget* pChild = pFirst;
   while (pChild) {
     pChild = GetNextSiblingWidget(pChild);
     ++iRet;
   }
   return iRet;
 }
 IFWL_Widget* CFWL_WidgetMgr::GetSiblingRadioButton(IFWL_Widget* pWidget,
-                                                   FX_BOOL bNext) {
+                                                   bool bNext) {
   return nullptr;
 }
 IFWL_Widget* CFWL_WidgetMgr::GetRadioButtonGroupHeader(
     IFWL_Widget* pRadioButton) {
   IFWL_Widget* pNext = pRadioButton;
   while (pNext) {
     if (pNext->GetStyles() & FWL_WGTSTYLE_Group)
       return pNext;
-    pNext = GetSiblingRadioButton(pNext, FALSE);
+    pNext = GetSiblingRadioButton(pNext, false);
   }
   pNext = GetLastSiblingWidget(pRadioButton);
-  while ((pNext = GetSiblingRadioButton(pNext, FALSE)) != nullptr &&
+  while ((pNext = GetSiblingRadioButton(pNext, false)) != nullptr &&
          pNext != pRadioButton) {
     if (pNext->GetStyles() & FWL_WGTSTYLE_Group)
       return pNext;
   }
   pNext = GetFirstSiblingWidget(pRadioButton);
-  return GetSiblingRadioButton(pNext, TRUE);
+  return GetSiblingRadioButton(pNext, true);
 }
 void CFWL_WidgetMgr::GetSameGroupRadioButton(
     IFWL_Widget* pRadioButton,
     CFX_ArrayTemplate<IFWL_Widget*>& group) {
   IFWL_Widget* pFirst = GetFirstSiblingWidget(pRadioButton);
   if (!pFirst) {
     pFirst = pRadioButton;
   }
   int32_t iGroup = CountRadioButtonGroup(pFirst);
   if (iGroup < 2) {
     IFWL_Widget* pNext = pFirst;
-    while ((pNext = GetSiblingRadioButton(pNext, TRUE)) != nullptr) {
+    while ((pNext = GetSiblingRadioButton(pNext, true)) != nullptr) {
       group.Add(pNext);
     }
     return;
   }
   IFWL_Widget* pNext = GetRadioButtonGroupHeader(pRadioButton);
   do {
     group.Add(pNext);
-    pNext = GetSiblingRadioButton(pNext, TRUE);
+    pNext = GetSiblingRadioButton(pNext, true);
     if (!pNext)
-      pNext = GetSiblingRadioButton(pFirst, TRUE);
+      pNext = GetSiblingRadioButton(pFirst, true);
   } while (pNext && ((pNext->GetStyles() & FWL_WGTSTYLE_Group) == 0));
 }
 IFWL_Widget* CFWL_WidgetMgr::GetDefaultButton(IFWL_Widget* pParent) {
   if ((pParent->GetClassID() == FWL_Type::PushButton) &&
       (pParent->GetStates() & (1 << (FWL_WGTSTATE_MAX + 2)))) {
     return pParent;
   }
   IFWL_Widget* child =
       pParent->GetOwnerApp()->GetWidgetMgr()->GetFirstChildWidget(pParent);
   while (child) {
@@ skipping 48 matching lines @@
     pChild = pChild->pNext;
   }
   if (pIndex) {
     return 0;
   } else if (pItem) {
     return -1;
   }
   return iCount - 1;
 }
 
-FX_BOOL CFWL_WidgetMgr::IsAbleNative(IFWL_Widget* pWidget) const {
+bool CFWL_WidgetMgr::IsAbleNative(IFWL_Widget* pWidget) const {
   if (!pWidget)
-    return FALSE;
+    return false;
   if (!pWidget->IsInstance(FX_WSTRC(FWL_CLASS_Form))) {
-    return FALSE;
+    return false;
   }
   uint32_t dwStyles = pWidget->GetStyles();
   return ((dwStyles & FWL_WGTSTYLE_WindowTypeMask) ==
           FWL_WGTSTYLE_OverLapper) ||
          (dwStyles & FWL_WGTSTYLE_Popup);
 }
 
 bool CFWL_WidgetMgr::IsThreadEnabled() {
   return !(m_dwCapability & FWL_WGTMGR_DisableThread);
 }
 
 bool CFWL_WidgetMgr::IsFormDisabled() {
   return !!(m_dwCapability & FWL_WGTMGR_DisableForm);
 }
 
-FX_BOOL CFWL_WidgetMgr::GetAdapterPopupPos(IFWL_Widget* pWidget,
-                                           FX_FLOAT fMinHeight,
-                                           FX_FLOAT fMaxHeight,
-                                           const CFX_RectF& rtAnchor,
-                                           CFX_RectF& rtPopup) {
+bool CFWL_WidgetMgr::GetAdapterPopupPos(IFWL_Widget* pWidget,
+                                        FX_FLOAT fMinHeight,
+                                        FX_FLOAT fMaxHeight,
+                                        const CFX_RectF& rtAnchor,
+                                        CFX_RectF& rtPopup) {
   CXFA_FWLAdapterWidgetMgr* pSDApapter = GetAdapterWidgetMgr();
   return pSDApapter->GetPopupPos(pWidget, fMinHeight, fMaxHeight, rtAnchor,
                                  rtPopup);
 }
 CFWL_WidgetMgrDelegate::CFWL_WidgetMgrDelegate(CFWL_WidgetMgr* pWidgetMgr)
     : m_pWidgetMgr(pWidgetMgr) {}
 FWL_Error CFWL_WidgetMgrDelegate::OnSetCapability(uint32_t dwCapability) {
   m_pWidgetMgr->m_dwCapability = dwCapability;
   return FWL_Error::Succeeded;
 }
@@ skipping 78 matching lines @@
   m_pWidgetMgr->ResetRedrawCounts(pWidget);
 }
 
 void CFWL_WidgetMgrDelegate::DrawChild(IFWL_Widget* parent,
                                        const CFX_RectF& rtClip,
                                        CFX_Graphics* pGraphics,
                                        const CFX_Matrix* pMatrix) {
   if (!parent)
     return;
 
-  FX_BOOL bFormDisable = m_pWidgetMgr->IsFormDisabled();
+  bool bFormDisable = m_pWidgetMgr->IsFormDisabled();
   IFWL_Widget* pNextChild = m_pWidgetMgr->GetFirstChildWidget(parent);
   while (pNextChild) {
     IFWL_Widget* child = pNextChild;
     pNextChild = m_pWidgetMgr->GetNextSiblingWidget(child);
     if (child->GetStates() & FWL_WGTSTATE_Invisible)
       continue;
 
     CFX_RectF rtWidget;
     child->GetWidgetRect(rtWidget);
     if (rtWidget.IsEmpty())
       continue;
 
     CFX_Matrix widgetMatrix;
     CFX_RectF clipBounds(rtWidget);
     if (!bFormDisable)
-      child->GetMatrix(widgetMatrix, TRUE);
+      child->GetMatrix(widgetMatrix, true);
     if (pMatrix)
       widgetMatrix.Concat(*pMatrix);
 
     if (!bFormDisable) {
       widgetMatrix.TransformPoint(clipBounds.left, clipBounds.top);
       clipBounds.Intersect(rtClip);
       if (clipBounds.IsEmpty())
         continue;
 
       pGraphics->SaveGraphState();
       pGraphics->SetClipRect(clipBounds);
     }
-    widgetMatrix.Translate(rtWidget.left, rtWidget.top, TRUE);
+    widgetMatrix.Translate(rtWidget.left, rtWidget.top, true);
 
     if (IFWL_WidgetDelegate* pDelegate = child->GetDelegate()) {
       if (m_pWidgetMgr->IsFormDisabled() ||
           IsNeedRepaint(child, &widgetMatrix, rtClip)) {
         pDelegate->OnDrawWidget(pGraphics, &widgetMatrix);
       }
     }
     if (!bFormDisable)
       pGraphics->RestoreGraphState();
 
@@ skipping 33 matching lines @@
     pGraphics->Transfer(pItem->pOffscreen.get(), rtClip.left, rtClip.top,
                         rtClip, pMatrix);
 #ifdef _WIN32
     pItem->pOffscreen->ClearClip();
 #endif
   }
   CFWL_WidgetMgrItem* pItem = m_pWidgetMgr->GetWidgetMgrItem(pWidget);
   pItem->iRedrawCounter = 0;
 }
 
-FX_BOOL CFWL_WidgetMgrDelegate::IsNeedRepaint(IFWL_Widget* pWidget,
-                                              CFX_Matrix* pMatrix,
-                                              const CFX_RectF& rtDirty) {
+bool CFWL_WidgetMgrDelegate::IsNeedRepaint(IFWL_Widget* pWidget,
+                                           CFX_Matrix* pMatrix,
+                                           const CFX_RectF& rtDirty) {
   CFWL_WidgetMgrItem* pItem = m_pWidgetMgr->GetWidgetMgrItem(pWidget);
   if (pItem && pItem->iRedrawCounter > 0) {
     pItem->iRedrawCounter = 0;
-    return TRUE;
+    return true;
   }
   CFX_RectF rtWidget;
   pWidget->GetWidgetRect(rtWidget);
   rtWidget.left = rtWidget.top = 0;
   pMatrix->TransformRect(rtWidget);
   if (!rtWidget.IntersectWith(rtDirty))
-    return FALSE;
+    return false;
 
   IFWL_Widget* pChild =
       pWidget->GetOwnerApp()->GetWidgetMgr()->GetFirstChildWidget(pWidget);
   if (!pChild)
-    return TRUE;
+    return true;
 
   CFX_RectF rtChilds;
   rtChilds.Empty();
-  FX_BOOL bChildIntersectWithDirty = FALSE;
-  FX_BOOL bOrginPtIntersectWidthChild = FALSE;
-  FX_BOOL bOrginPtIntersectWidthDirty =
+  bool bChildIntersectWithDirty = false;
+  bool bOrginPtIntersectWidthChild = false;
+  bool bOrginPtIntersectWidthDirty =
       rtDirty.Contains(rtWidget.left, rtWidget.top);
   static FWL_NEEDREPAINTHITDATA hitPoint[kNeedRepaintHitPoints];
   FXSYS_memset(hitPoint, 0, sizeof(hitPoint));
   FX_FLOAT fxPiece = rtWidget.width / kNeedRepaintHitPiece;
   FX_FLOAT fyPiece = rtWidget.height / kNeedRepaintHitPiece;
   hitPoint[2].hitPoint.x = hitPoint[6].hitPoint.x = rtWidget.left;
   hitPoint[0].hitPoint.x = hitPoint[3].hitPoint.x = hitPoint[7].hitPoint.x =
       hitPoint[10].hitPoint.x = fxPiece + rtWidget.left;
   hitPoint[1].hitPoint.x = hitPoint[4].hitPoint.x = hitPoint[8].hitPoint.x =
       hitPoint[11].hitPoint.x = fxPiece * 2 + rtWidget.left;
   hitPoint[5].hitPoint.x = hitPoint[9].hitPoint.x =
       rtWidget.width + rtWidget.left;
   hitPoint[0].hitPoint.y = hitPoint[1].hitPoint.y = rtWidget.top;
   hitPoint[2].hitPoint.y = hitPoint[3].hitPoint.y = hitPoint[4].hitPoint.y =
       hitPoint[5].hitPoint.y = fyPiece + rtWidget.top;
   hitPoint[6].hitPoint.y = hitPoint[7].hitPoint.y = hitPoint[8].hitPoint.y =
       hitPoint[9].hitPoint.y = fyPiece * 2 + rtWidget.top;
   hitPoint[10].hitPoint.y = hitPoint[11].hitPoint.y =
       rtWidget.height + rtWidget.top;
   do {
     CFX_RectF rect;
     pChild->GetWidgetRect(rect);
     CFX_RectF r = rect;
     r.left += rtWidget.left;
     r.top += rtWidget.top;
     if (r.IsEmpty())
       continue;
     if (r.Contains(rtDirty))
-      return FALSE;
+      return false;
     if (!bChildIntersectWithDirty && r.IntersectWith(rtDirty))
-      bChildIntersectWithDirty = TRUE;
+      bChildIntersectWithDirty = true;
     if (bOrginPtIntersectWidthDirty && !bOrginPtIntersectWidthChild)
       bOrginPtIntersectWidthChild = rect.Contains(0, 0);
 
     if (rtChilds.IsEmpty())
       rtChilds = rect;
     else if (!(pChild->GetStates() & FWL_WGTSTATE_Invisible))
       rtChilds.Union(rect);
 
     for (int32_t i = 0; i < kNeedRepaintHitPoints; i++) {
       if (hitPoint[i].bNotContainByDirty || hitPoint[i].bNotNeedRepaint)
         continue;
       if (!rtDirty.Contains(hitPoint[i].hitPoint)) {
         hitPoint[i].bNotContainByDirty = true;
         continue;
       }
       if (r.Contains(hitPoint[i].hitPoint))
         hitPoint[i].bNotNeedRepaint = true;
     }
     pChild =
         pChild->GetOwnerApp()->GetWidgetMgr()->GetNextSiblingWidget(pChild);
   } while (pChild);
 
   if (!bChildIntersectWithDirty)
-    return TRUE;
+    return true;
   if (bOrginPtIntersectWidthDirty && !bOrginPtIntersectWidthChild)
-    return TRUE;
+    return true;
   if (rtChilds.IsEmpty())
-    return TRUE;
+    return true;
 
   int32_t repaintPoint = kNeedRepaintHitPoints;
   for (int32_t i = 0; i < kNeedRepaintHitPoints; i++) {
     if (hitPoint[i].bNotNeedRepaint)
       repaintPoint--;
   }
   if (repaintPoint > 0)
-    return TRUE;
+    return true;
 
   pMatrix->TransformRect(rtChilds);
   if (rtChilds.Contains(rtDirty) || rtChilds.Contains(rtWidget))
-    return FALSE;
-  return TRUE;
+    return false;
+  return true;
 }
 
-FX_BOOL CFWL_WidgetMgrDelegate::bUseOffscreenDirect(IFWL_Widget* pWidget) {
+bool CFWL_WidgetMgrDelegate::bUseOffscreenDirect(IFWL_Widget* pWidget) {
   CFWL_WidgetMgrItem* pItem = m_pWidgetMgr->GetWidgetMgrItem(pWidget);
   if (!FWL_UseOffscreen(pWidget) || !(pItem->pOffscreen))
-    return FALSE;
+    return false;
 
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_) || (_FX_OS_ == _FX_WIN64_)
   if (pItem->bOutsideChanged) {
     CFX_RectF r;
     pWidget->GetWidgetRect(r);
     CFX_RectF temp(m_pWidgetMgr->m_rtScreen);
     temp.Deflate(50, 50);
     if (!temp.Contains(r))
-      return FALSE;
+      return false;
 
-    pItem->bOutsideChanged = FALSE;
+    pItem->bOutsideChanged = false;
   }
 #endif
 
   return pItem->iRedrawCounter == 0;
 }
 
 CFWL_WidgetMgrItem::CFWL_WidgetMgrItem() : CFWL_WidgetMgrItem(nullptr) {}
 
 CFWL_WidgetMgrItem::CFWL_WidgetMgrItem(IFWL_Widget* widget)
     : pParent(nullptr),
       pOwner(nullptr),
       pChild(nullptr),
       pPrevious(nullptr),
       pNext(nullptr),
       pWidget(widget),
       iRedrawCounter(0)
 #if (_FX_OS_ == _FX_WIN32_DESKTOP_) || (_FX_OS_ == _FX_WIN64_)
       ,
-      bOutsideChanged(FALSE)
+      bOutsideChanged(false)
 #endif
 {
 }
 
 CFWL_WidgetMgrItem::~CFWL_WidgetMgrItem() {}