Remove FX_BOOL from xfa.

xfa/fwl/core/ifwl_monthcalendar.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/ifwl_monthcalendar.h"
 
 #include <algorithm>
 
@@ skipping 105 matching lines @@
       pTheme->GetCapacity(&params, CFWL_WidgetCapacity::December));
 }
 
 }  // namespace
 
 IFWL_MonthCalendar::IFWL_MonthCalendar(
     const IFWL_App* app,
     const CFWL_WidgetImpProperties& properties,
     IFWL_Widget* pOuter)
     : IFWL_Widget(app, properties, pOuter),
-      m_bInit(FALSE),
+      m_bInit(false),
       m_pDateTime(new CFX_DateTime),
       m_iCurYear(2011),
       m_iCurMonth(1),
       m_iYear(2011),
       m_iMonth(1),
       m_iDay(1),
       m_iHovered(-1),
       m_iLBtnPartStates(CFWL_PartState_Normal),
       m_iRBtnPartStates(CFWL_PartState_Normal),
       m_iMaxSel(1) {
@@ skipping 13 matching lines @@
 
 IFWL_MonthCalendar::~IFWL_MonthCalendar() {
   ClearDateItem();
   m_arrSelDays.RemoveAll();
 }
 
 FWL_Type IFWL_MonthCalendar::GetClassID() const {
   return FWL_Type::MonthCalendar;
 }
 
-FWL_Error IFWL_MonthCalendar::GetWidgetRect(CFX_RectF& rect,
-                                            FX_BOOL bAutoSize) {
+FWL_Error IFWL_MonthCalendar::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
-    CFX_SizeF fs = CalcSize(TRUE);
+    CFX_SizeF fs = CalcSize(true);
     rect.Set(0, 0, fs.x, fs.y);
-    IFWL_Widget::GetWidgetRect(rect, TRUE);
+    IFWL_Widget::GetWidgetRect(rect, true);
   } else {
     rect = m_pProperties->m_rtWidget;
   }
   return FWL_Error::Succeeded;
 }
 
 FWL_Error IFWL_MonthCalendar::Update() {
   if (IsLocked()) {
     return FWL_Error::Indefinite;
   }
@@ skipping 40 matching lines @@
     DrawWeekNumberSep(pGraphics, pTheme, pMatrix);
     DrawWeekNumber(pGraphics, pTheme, pMatrix);
   }
   return FWL_Error::Succeeded;
 }
 
 int32_t IFWL_MonthCalendar::CountSelect() {
   return m_arrSelDays.GetSize();
 }
 
-FX_BOOL IFWL_MonthCalendar::GetSelect(int32_t& iYear,
-                                      int32_t& iMonth,
-                                      int32_t& iDay,
-                                      int32_t nIndex) {
+bool IFWL_MonthCalendar::GetSelect(int32_t& iYear,
+                                   int32_t& iMonth,
+                                   int32_t& iDay,
+                                   int32_t nIndex) {
   if (nIndex >= m_arrSelDays.GetSize()) {
-    return FALSE;
+    return false;
   }
   iYear = m_iCurYear;
   iMonth = m_iCurMonth;
   iDay = m_arrSelDays[nIndex];
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::SetSelect(int32_t iYear,
-                                      int32_t iMonth,
-                                      int32_t iDay) {
+bool IFWL_MonthCalendar::SetSelect(int32_t iYear,
+                                   int32_t iMonth,
+                                   int32_t iDay) {
   ChangeToMonth(iYear, iMonth);
   return AddSelDay(iDay);
 }
 
 void IFWL_MonthCalendar::DrawBkground(CFX_Graphics* pGraphics,
                                       IFWL_ThemeProvider* pTheme,
                                       const CFX_Matrix* pMatrix) {
   CFWL_ThemeBackground params;
   params.m_pWidget = this;
   params.m_iPart = CFWL_Part::Background;
@@ skipping 307 matching lines @@
   params.m_iPart = CFWL_Part::TodayCircle;
   params.m_pGraphics = pGraphics;
   params.m_dwStates = CFWL_PartState_Normal;
   params.m_rtPart = m_rtTodayFlag;
   if (pMatrix) {
     params.m_matrix.Concat(*pMatrix);
   }
   pTheme->DrawBackground(&params);
 }
 
-CFX_SizeF IFWL_MonthCalendar::CalcSize(FX_BOOL bAutoSize) {
+CFX_SizeF IFWL_MonthCalendar::CalcSize(bool bAutoSize) {
   if (!m_pProperties->m_pThemeProvider)
     return CFX_SizeF();
 
   if (!bAutoSize) {
     GetClientRect(m_rtClient);
     return CFX_SizeF(m_rtClient.width, m_rtClient.height);
   }
 
   CFX_SizeF fs;
   CFWL_ThemePart params;
@@ skipping 99 matching lines @@
     m_rtDates.Set(m_rtClient.left + MONTHCAL_HEADER_BTN_HMARGIN,
                   m_rtWeek.bottom(),
                   m_rtClient.width - MONTHCAL_HEADER_BTN_HMARGIN * 2,
                   m_szCell.y * (MONTHCAL_ROWS - 3) +
                       MONTHCAL_VMARGIN * (MONTHCAL_ROWS - 3) * 2);
   }
   CalDateItem();
 }
 
 void IFWL_MonthCalendar::CalDateItem() {
-  FX_BOOL bNewWeek = FALSE;
+  bool bNewWeek = false;
   int32_t iWeekOfMonth = 0;
   FX_FLOAT fLeft = m_rtDates.left;
   FX_FLOAT fTop = m_rtDates.top;
   int32_t iCount = m_arrDates.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     FWL_DATEINFO* pDateInfo = m_arrDates.GetAt(i);
     if (bNewWeek) {
       iWeekOfMonth++;
-      bNewWeek = FALSE;
+      bNewWeek = false;
     }
     pDateInfo->rect.Set(
         fLeft + pDateInfo->iDayOfWeek * (m_szCell.x + (MONTHCAL_HMARGIN * 2)),
         fTop + iWeekOfMonth * (m_szCell.y + (MONTHCAL_VMARGIN * 2)),
         m_szCell.x + (MONTHCAL_HMARGIN * 2),
         m_szCell.y + (MONTHCAL_VMARGIN * 2));
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_MCD_WeekNumbers) {
       pDateInfo->rect.Offset(m_fWeekNumWid, 0);
     }
     if (pDateInfo->iDayOfWeek >= 6) {
-      bNewWeek = TRUE;
+      bNewWeek = true;
     }
   }
 }
 
 void IFWL_MonthCalendar::GetCapValue() {
   if (!m_pProperties->m_pThemeProvider) {
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
   }
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   CFWL_ThemePart part;
@@ skipping 54 matching lines @@
   m_fMCHei = *static_cast<FX_FLOAT*>(
       pTheme->GetCapacity(&part, CFWL_WidgetCapacity::Height));
 }
 
 int32_t IFWL_MonthCalendar::CalWeekNumber(int32_t iYear,
                                           int32_t iMonth,
                                           int32_t iDay) {
   return 0;
 }
 
-FX_BOOL IFWL_MonthCalendar::GetMinDate(int32_t& iYear,
-                                       int32_t& iMonth,
-                                       int32_t& iDay) {
+bool IFWL_MonthCalendar::GetMinDate(int32_t& iYear,
+                                    int32_t& iMonth,
+                                    int32_t& iDay) {
   iYear = m_dtMin.iYear;
   iMonth = m_dtMin.iMonth;
   iDay = m_dtMin.iDay;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::SetMinDate(int32_t iYear,
-                                       int32_t iMonth,
-                                       int32_t iDay) {
+bool IFWL_MonthCalendar::SetMinDate(int32_t iYear,
+                                    int32_t iMonth,
+                                    int32_t iDay) {
   m_dtMin = DATE(iYear, iMonth, iDay);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::GetMaxDate(int32_t& iYear,
-                                       int32_t& iMonth,
-                                       int32_t& iDay) {
+bool IFWL_MonthCalendar::GetMaxDate(int32_t& iYear,
+                                    int32_t& iMonth,
+                                    int32_t& iDay) {
   iYear = m_dtMax.iYear;
   iMonth = m_dtMax.iMonth;
   iDay = m_dtMax.iDay;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::SetMaxDate(int32_t iYear,
-                                       int32_t iMonth,
-                                       int32_t iDay) {
+bool IFWL_MonthCalendar::SetMaxDate(int32_t iYear,
+                                    int32_t iMonth,
+                                    int32_t iDay) {
   m_dtMax = DATE(iYear, iMonth, iDay);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::InitDate() {
+bool IFWL_MonthCalendar::InitDate() {
   if (m_pProperties->m_pDataProvider) {
     IFWL_MonthCalendarDP* pDateProv =
         static_cast<IFWL_MonthCalendarDP*>(m_pProperties->m_pDataProvider);
     m_iYear = pDateProv->GetCurYear(this);
     m_iMonth = pDateProv->GetCurMonth(this);
     m_iDay = pDateProv->GetCurDay(this);
     m_iCurYear = m_iYear;
     m_iCurMonth = m_iMonth;
   } else {
     m_iDay = 1;
     m_iMonth = 1;
     m_iYear = 1;
     m_iCurYear = m_iYear;
     m_iCurMonth = m_iMonth;
   }
   GetTodayText(m_iYear, m_iMonth, m_iDay, m_wsToday);
   GetHeadText(m_iCurYear, m_iCurMonth, m_wsHead);
   m_dtMin = DATE(1500, 12, 1);
   m_dtMax = DATE(2200, 1, 1);
-  return TRUE;
+  return true;
 }
 
 void IFWL_MonthCalendar::ClearDateItem() {
   for (int32_t i = 0; i < m_arrDates.GetSize(); i++)
     delete m_arrDates.GetAt(i);
 
   m_arrDates.RemoveAll();
 }
 
 void IFWL_MonthCalendar::ReSetDateItem() {
@@ skipping 14 matching lines @@
       dwStates |= FWL_ITEMSTATE_MCD_Selected;
     }
     CFX_RectF rtDate;
     rtDate.Set(0, 0, 0, 0);
     m_arrDates.Add(
         new FWL_DATEINFO(i + 1, iDayOfWeek, dwStates, rtDate, wsDay));
     iDayOfWeek++;
   }
 }
 
-FX_BOOL IFWL_MonthCalendar::NextMonth() {
+bool IFWL_MonthCalendar::NextMonth() {
   int32_t iYear = m_iCurYear, iMonth = m_iCurMonth;
   if (iMonth >= 12) {
     iMonth = 1;
     iYear++;
   } else {
     iMonth++;
   }
   DATE dt(m_iCurYear, m_iCurMonth, 1);
   if (!(dt < m_dtMax)) {
-    return FALSE;
+    return false;
   }
   m_iCurYear = iYear, m_iCurMonth = iMonth;
   ChangeToMonth(m_iCurYear, m_iCurMonth);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::PrevMonth() {
+bool IFWL_MonthCalendar::PrevMonth() {
   int32_t iYear = m_iCurYear, iMonth = m_iCurMonth;
   if (iMonth <= 1) {
     iMonth = 12;
     iYear--;
   } else {
     iMonth--;
   }
   DATE dt(m_iCurYear, m_iCurMonth, 1);
   if (!(dt > m_dtMin)) {
-    return FALSE;
+    return false;
   }
   m_iCurYear = iYear, m_iCurMonth = iMonth;
   ChangeToMonth(m_iCurYear, m_iCurMonth);
-  return TRUE;
+  return true;
 }
 
 void IFWL_MonthCalendar::ChangeToMonth(int32_t iYear, int32_t iMonth) {
   m_iCurYear = iYear;
   m_iCurMonth = iMonth;
   m_iHovered = -1;
   ClearDateItem();
   ReSetDateItem();
   CalDateItem();
   GetHeadText(m_iCurYear, m_iCurMonth, m_wsHead);
 }
 
-FX_BOOL IFWL_MonthCalendar::RemoveSelDay(int32_t iDay, FX_BOOL bAll) {
+bool IFWL_MonthCalendar::RemoveSelDay(int32_t iDay, bool bAll) {
   if (iDay == -1 && !bAll) {
-    return FALSE;
+    return false;
   }
   if (bAll) {
     int32_t iCount = m_arrSelDays.GetSize();
     int32_t iDatesCount = m_arrDates.GetSize();
     for (int32_t i = 0; i < iCount; i++) {
       int32_t iSelDay = m_arrSelDays.GetAt(i);
       if (iSelDay <= iDatesCount) {
         FWL_DATEINFO* pDateInfo = m_arrDates.GetAt(iSelDay - 1);
         pDateInfo->dwStates &= ~FWL_ITEMSTATE_MCD_Selected;
       }
     }
     m_arrSelDays.RemoveAll();
   } else {
     int32_t index = m_arrSelDays.Find(iDay);
     if (index == -1) {
-      return FALSE;
+      return false;
     }
     int32_t iSelDay = m_arrSelDays.GetAt(iDay);
     int32_t iDatesCount = m_arrDates.GetSize();
     if (iSelDay <= iDatesCount) {
       FWL_DATEINFO* pDateInfo = m_arrDates.GetAt(iSelDay - 1);
       pDateInfo->dwStates &= ~FWL_ITEMSTATE_MCD_Selected;
     }
     m_arrSelDays.RemoveAt(index);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::AddSelDay(int32_t iDay) {
+bool IFWL_MonthCalendar::AddSelDay(int32_t iDay) {
   ASSERT(iDay > 0);
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_MCD_MultiSelect) {
   } else {
     if (m_arrSelDays.Find(iDay) == -1) {
-      RemoveSelDay(-1, TRUE);
+      RemoveSelDay(-1, true);
       if (iDay <= m_arrDates.GetSize()) {
         FWL_DATEINFO* pDateInfo = m_arrDates.GetAt(iDay - 1);
         pDateInfo->dwStates |= FWL_ITEMSTATE_MCD_Selected;
       }
       m_arrSelDays.Add(iDay);
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL IFWL_MonthCalendar::JumpToToday() {
+bool IFWL_MonthCalendar::JumpToToday() {
   if (m_iYear != m_iCurYear || m_iMonth != m_iCurMonth) {
     m_iCurYear = m_iYear;
     m_iCurMonth = m_iMonth;
     ChangeToMonth(m_iYear, m_iMonth);
     AddSelDay(m_iDay);
   } else {
     if (m_arrSelDays.Find(m_iDay) == -1) {
       AddSelDay(m_iDay);
     }
   }
-  return TRUE;
+  return true;
 }
 
 void IFWL_MonthCalendar::GetHeadText(int32_t iYear,
                                      int32_t iMonth,
                                      CFX_WideString& wsHead) {
   ASSERT(iMonth > 0 && iMonth < 13);
   static const FX_WCHAR* const pMonth[] = {
       L"January",   L"February", L"March",    L"April",
       L"May",       L"June",     L"July",     L"August",
       L"September", L"October",  L"November", L"December"};
@@ skipping 11 matching lines @@
   int32_t iCount = m_arrDates.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     FWL_DATEINFO* pDateInfo = m_arrDates.GetAt(i);
     if (pDateInfo->rect.Contains(x, y)) {
       return ++i;
     }
   }
   return -1;
 }
 
-FX_BOOL IFWL_MonthCalendar::GetDayRect(int32_t iDay, CFX_RectF& rtDay) {
+bool IFWL_MonthCalendar::GetDayRect(int32_t iDay, CFX_RectF& rtDay) {
   if (iDay <= 0 || iDay > m_arrDates.GetSize()) {
-    return FALSE;
+    return false;
   }
   FWL_DATEINFO* pDateInfo = m_arrDates[iDay - 1];
   if (!pDateInfo)
-    return FALSE;
+    return false;
   rtDay = pDateInfo->rect;
-  return TRUE;
+  return true;
 }
 
 void IFWL_MonthCalendar::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
     return;
 
   CFWL_MessageType dwMsgCode = pMessage->GetClassID();
   switch (dwMsgCode) {
     case CFWL_MessageType::SetFocus:
-      OnFocusChanged(pMessage, TRUE);
+      OnFocusChanged(pMessage, true);
       break;
     case CFWL_MessageType::KillFocus:
-      OnFocusChanged(pMessage, FALSE);
+      OnFocusChanged(pMessage, false);
       break;
     case CFWL_MessageType::Key:
       break;
     case CFWL_MessageType::Mouse: {
       CFWL_MsgMouse* pMouse = static_cast<CFWL_MsgMouse*>(pMessage);
       switch (pMouse->m_dwCmd) {
         case FWL_MouseCommand::LeftButtonDown:
           OnLButtonDown(pMouse);
           break;
         case FWL_MouseCommand::LeftButtonUp:
@@ skipping 14 matching lines @@
       break;
   }
   IFWL_Widget::OnProcessMessage(pMessage);
 }
 
 void IFWL_MonthCalendar::OnDrawWidget(CFX_Graphics* pGraphics,
                                       const CFX_Matrix* pMatrix) {
   DrawWidget(pGraphics, pMatrix);
 }
 
-void IFWL_MonthCalendar::OnFocusChanged(CFWL_Message* pMsg, FX_BOOL bSet) {
+void IFWL_MonthCalendar::OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
   if (bSet)
     m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
   else
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
 
   Repaint(&m_rtClient);
 }
 
 void IFWL_MonthCalendar::OnLButtonDown(CFWL_MsgMouse* pMsg) {
   if (m_rtLBtn.Contains(pMsg->m_fx, pMsg->m_fy)) {
@@ skipping 10 matching lines @@
       Repaint(&m_rtClient);
     }
   } else {
     if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_MCD_MultiSelect)) {
       int32_t iOldSel = 0;
       if (m_arrSelDays.GetSize() <= 0)
         return;
       iOldSel = m_arrSelDays[0];
 
       int32_t iCurSel = GetDayAtPoint(pMsg->m_fx, pMsg->m_fy);
-      FX_BOOL bSelChanged = iCurSel > 0 && iCurSel != iOldSel;
+      bool bSelChanged = iCurSel > 0 && iCurSel != iOldSel;
       if (bSelChanged) {
         FWL_DATEINFO* lpDatesInfo = m_arrDates.GetAt(iCurSel - 1);
         CFX_RectF rtInvalidate(lpDatesInfo->rect);
         if (iOldSel > 0) {
           lpDatesInfo = m_arrDates.GetAt(iOldSel - 1);
           rtInvalidate.Union(lpDatesInfo->rect);
         }
         AddSelDay(iCurSel);
         CFWL_EvtClick wmClick;
         wmClick.m_pSrcTarget = this;
@@ skipping 22 matching lines @@
     int32_t iDay = GetDayAtPoint(pMsg->m_fx, pMsg->m_fy);
     if (iDay != -1)
       AddSelDay(iDay);
   }
 }
 
 void IFWL_MonthCalendar::OnMouseMove(CFWL_MsgMouse* pMsg) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_MCD_MultiSelect)
     return;
 
-  FX_BOOL bRepaint = FALSE;
+  bool bRepaint = false;
   CFX_RectF rtInvalidate;
   rtInvalidate.Set(0, 0, 0, 0);
   if (m_rtDates.Contains(pMsg->m_fx, pMsg->m_fy)) {
     int32_t iHover = GetDayAtPoint(pMsg->m_fx, pMsg->m_fy);
     bRepaint = m_iHovered != iHover;
     if (bRepaint) {
       if (m_iHovered > 0)
         GetDayRect(m_iHovered, rtInvalidate);
       if (iHover > 0) {
         CFX_RectF rtDay;
@@ skipping 33 matching lines @@
                            uint32_t dwSt,
                            CFX_RectF rc,
                            CFX_WideString& wsday)
     : iDay(day),
       iDayOfWeek(dayofweek),
       dwStates(dwSt),
       rect(rc),
       wsDay(wsday) {}
 
 FWL_DATEINFO::~FWL_DATEINFO() {}