FX_BOOL considered harmful.

core/src/fxge/ge/fx_ge_path.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 "../../../../third_party/base/numerics/safe_math.h"
 #include "../../../include/fxcrt/fx_system.h"
 #include "../../../include/fxge/fx_ge.h"
 
@@ skipping 91 matching lines @@
             uint8_t* mask_scan = mask_dib->GetBuffer() + (row - top) * mask_dib->GetPitch();
             uint8_t* new_scan = new_dib->GetBuffer() + (row - new_box.top) * new_dib->GetPitch();
             for (int col = new_box.left; col < new_box.right; col ++) {
                 new_scan[col - new_box.left] = old_scan[col - m_Box.left] * mask_scan[col - left] / 255;
             }
         }
         m_Box = new_box;
         m_Mask = new_mask;
         return;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
 }
 CFX_PathData::CFX_PathData()
 {
     m_PointCount = m_AllocCount = 0;
     m_pPoints = NULL;
 }
 CFX_PathData::~CFX_PathData()
 {
     if (m_pPoints) {
         FX_Free(m_pPoints);
@@ skipping 125 matching lines @@
     FX_FLOAT dx1 = hw * dy / ll;
     FX_FLOAT dy1 = hw * dx / ll;
     rect.UpdateRect(mx - dx1, my + dy1);
     rect.UpdateRect(mx + dx1, my - dy1);
 }
 static void _UpdateLineJoinPoints(CFX_FloatRect& rect, FX_FLOAT start_x, FX_FLOAT start_y,
                                   FX_FLOAT middle_x, FX_FLOAT middle_y, FX_FLOAT end_x, FX_FLOAT end_y,
                                   FX_FLOAT half_width, FX_FLOAT miter_limit)
 {
     FX_FLOAT start_k = 0, start_c = 0, end_k = 0, end_c = 0, start_len = 0, start_dc = 0, end_len = 0, end_dc = 0;
-    FX_BOOL bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
-    FX_BOOL bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
+    bool bStartVert = FXSYS_fabs(start_x - middle_x) < 1.0f / 20;
+    bool bEndVert = FXSYS_fabs(middle_x - end_x) < 1.0f / 20;
     if (bStartVert && bEndVert) {
         int start_dir = middle_y > start_y ? 1 : -1;
         FX_FLOAT point_y = middle_y + half_width * start_dir;
         rect.UpdateRect(middle_x + half_width, point_y);
         rect.UpdateRect(middle_x - half_width, point_y);
         return;
     }
     if (!bStartVert) {
         start_k = FXSYS_Div(middle_y - start_y, middle_x - start_x);
         start_c = middle_y - FXSYS_Mul(start_k, middle_x);
@@ skipping 63 matching lines @@
     FX_FLOAT join_x = FXSYS_Div(end_outside_c - start_outside_c, start_k - end_k);
     FX_FLOAT join_y = FXSYS_Mul(start_k, join_x) + start_outside_c;
     rect.UpdateRect(join_x, join_y);
 }
 CFX_FloatRect CFX_PathData::GetBoundingBox(FX_FLOAT line_width, FX_FLOAT miter_limit) const
 {
     CFX_FloatRect rect(100000 * 1.0f, 100000 * 1.0f, -100000 * 1.0f, -100000 * 1.0f);
     int iPoint = 0;
     FX_FLOAT half_width = line_width;
     int iStartPoint, iEndPoint, iMiddlePoint;
-    FX_BOOL bJoin;
+    bool bJoin;
     while (iPoint < m_PointCount) {
         if (m_pPoints[iPoint].m_Flag == FXPT_MOVETO) {
             iStartPoint = iPoint + 1;
             iEndPoint = iPoint;
-            bJoin = FALSE;
+            bJoin = false;
         } else {
             if (m_pPoints[iPoint].m_Flag == FXPT_BEZIERTO) {
                 rect.UpdateRect(m_pPoints[iPoint].m_PointX, m_pPoints[iPoint].m_PointY);
                 rect.UpdateRect(m_pPoints[iPoint + 1].m_PointX, m_pPoints[iPoint + 1].m_PointY);
                 iPoint += 2;
             }
             if (iPoint == m_PointCount - 1 || m_pPoints[iPoint + 1].m_Flag == FXPT_MOVETO) {
                 iStartPoint = iPoint - 1;
                 iEndPoint = iPoint;
-                bJoin = FALSE;
+                bJoin = false;
             } else {
                 iStartPoint = iPoint - 1;
                 iMiddlePoint = iPoint;
                 iEndPoint = iPoint + 1;
-                bJoin = TRUE;
+                bJoin = true;
             }
         }
         FX_FLOAT start_x = m_pPoints[iStartPoint].m_PointX;
         FX_FLOAT start_y = m_pPoints[iStartPoint].m_PointY;
         FX_FLOAT end_x = m_pPoints[iEndPoint].m_PointX;
         FX_FLOAT end_y = m_pPoints[iEndPoint].m_PointY;
         if (bJoin) {
             FX_FLOAT middle_x = m_pPoints[iMiddlePoint].m_PointX;
             FX_FLOAT middle_y = m_pPoints[iMiddlePoint].m_PointY;
             _UpdateLineJoinPoints(rect, start_x, start_y, middle_x, middle_y, end_x, end_y, half_width, miter_limit);
         } else {
             _UpdateLineEndPoints(rect, start_x, start_y, end_x, end_y, half_width);
         }
         iPoint ++;
     }
     return rect;
 }
 void CFX_PathData::Transform(const CFX_AffineMatrix* pMatrix)
 {
     if (pMatrix == NULL) {
         return;
     }
     for (int i = 0; i < m_PointCount; i ++) {
         pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY);
     }
 }
-FX_BOOL CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* pMatrix, FX_BOOL&bThin, FX_BOOL bAdjust) const
+bool CFX_PathData::GetZeroAreaPath(CFX_PathData& NewPath, CFX_AffineMatrix* pMatrix, bool&bThin, bool bAdjust) const
 {
     if (m_PointCount < 3) {
-        return FALSE;
+        return false;
     }
     if (m_PointCount == 3 && (m_pPoints[0].m_Flag & FXPT_TYPE) == FXPT_MOVETO &&
             (m_pPoints[1].m_Flag & FXPT_TYPE) == FXPT_LINETO && (m_pPoints[2].m_Flag & FXPT_TYPE) == FXPT_LINETO
             && m_pPoints[0].m_PointX == m_pPoints[2].m_PointX && m_pPoints[0].m_PointY == m_pPoints[2].m_PointY) {
         NewPath.AddPointCount(2);
         if (bAdjust) {
             if (pMatrix) {
                 FX_FLOAT x = m_pPoints[0].m_PointX, y = m_pPoints[0].m_PointY;
                 pMatrix->TransformPoint(x, y);
                 x = (int)x + 0.5f;
                 y = (int)y + 0.5f;
                 NewPath.SetPoint(0, x, y, FXPT_MOVETO);
                 x = m_pPoints[1].m_PointX, y = m_pPoints[1].m_PointY;
                 pMatrix->TransformPoint(x, y);
                 x = (int)x + 0.5f;
                 y = (int)y + 0.5f;
                 NewPath.SetPoint(1, x, y, FXPT_LINETO);
                 pMatrix->SetIdentity();
             } else {
                 FX_FLOAT x = (int)m_pPoints[0].m_PointX + 0.5f, y = (int)m_pPoints[0].m_PointY + 0.5f;
                 NewPath.SetPoint(0, x, y, FXPT_MOVETO);
                 x = (int)m_pPoints[1].m_PointX + 0.5f, y = (int)m_pPoints[1].m_PointY + 0.5f;
                 NewPath.SetPoint(1, x, y, FXPT_LINETO);
             }
         } else {
             NewPath.SetPoint(0, m_pPoints[0].m_PointX, m_pPoints[0].m_PointY, FXPT_MOVETO);
             NewPath.SetPoint(1, m_pPoints[1].m_PointX, m_pPoints[1].m_PointY, FXPT_LINETO);
         }
         if (m_pPoints[0].m_PointX != m_pPoints[1].m_PointX && m_pPoints[0].m_PointY != m_pPoints[1].m_PointY) {
-            bThin = TRUE;
+            bThin = true;
         }
-        return TRUE;
+        return true;
     }
     if (((m_PointCount > 3) && (m_PointCount % 2))) {
         int mid = m_PointCount / 2;
-        FX_BOOL bZeroArea = FALSE;
+        bool bZeroArea = false;
         CFX_PathData t_path;
         for (int i = 0; i < mid; i++) {
             if (!(m_pPoints[mid - i - 1].m_PointX == m_pPoints[mid + i + 1].m_PointX
                     && m_pPoints[mid - i - 1].m_PointY == m_pPoints[mid + i + 1].m_PointY &&
                     ((m_pPoints[mid - i - 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO && (m_pPoints[mid + i + 1].m_Flag & FXPT_TYPE) != FXPT_BEZIERTO))) {
-                bZeroArea = TRUE;
+                bZeroArea = true;
                 break;
             }
             int new_count = t_path.GetPointCount();
             t_path.AddPointCount(2);
             t_path.SetPoint(new_count, m_pPoints[mid - i].m_PointX, m_pPoints[mid - i].m_PointY, FXPT_MOVETO);
             t_path.SetPoint(new_count + 1, m_pPoints[mid - i - 1].m_PointX, m_pPoints[mid - i - 1].m_PointY, FXPT_LINETO);
         }
         if (!bZeroArea) {
             NewPath.Append(&t_path, NULL);
-            bThin = TRUE;
-            return TRUE;
+            bThin = true;
+            return true;
         }
     }
     int stratPoint = 0;
     int next = 0, i;
     for (i = 0; i < m_PointCount; i++) {
         int point_type = m_pPoints[i].m_Flag & FXPT_TYPE;
         if (point_type == FXPT_MOVETO) {
             stratPoint = i;
         } else if (point_type == FXPT_LINETO) {
             next = (i + 1 - stratPoint) % (m_PointCount - stratPoint) + stratPoint;
@@ skipping 22 matching lines @@
                     NewPath.AddPointCount(2);
                     NewPath.SetPoint(new_count, m_pPoints[pre].m_PointX, m_pPoints[pre].m_PointY, FXPT_MOVETO);
                     NewPath.SetPoint(new_count + 1, m_pPoints[next].m_PointX, m_pPoints[next].m_PointY, FXPT_LINETO);
                 } else if ((m_pPoints[i - 1].m_Flag & FXPT_TYPE) == FXPT_MOVETO && (m_pPoints[next].m_Flag & FXPT_TYPE) == FXPT_LINETO &&
                            m_pPoints[i - 1].m_PointX == m_pPoints[next].m_PointX && m_pPoints[i - 1].m_PointY == m_pPoints[next].m_PointY
                            && m_pPoints[next].m_Flag & FXPT_CLOSEFIGURE) {
                     int new_count = NewPath.GetPointCount();
                     NewPath.AddPointCount(2);
                     NewPath.SetPoint(new_count, m_pPoints[i - 1].m_PointX, m_pPoints[i - 1].m_PointY, FXPT_MOVETO);
                     NewPath.SetPoint(new_count + 1, m_pPoints[i].m_PointX, m_pPoints[i].m_PointY, FXPT_LINETO);
-                    bThin = TRUE;
+                    bThin = true;
                 }
             }
         } else if (point_type == FXPT_BEZIERTO) {
             i += 2;
             continue;
         }
     }
     if (m_PointCount > 3 && NewPath.GetPointCount()) {
-        bThin = TRUE;
+        bThin = true;
     }
     if (NewPath.GetPointCount() == 0) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_PathData::IsRect() const
+bool CFX_PathData::IsRect() const
 {
     if (m_PointCount != 5 && m_PointCount != 4) {
-        return FALSE;
+        return false;
     }
     if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX ||
                                m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
             (m_pPoints[0].m_PointX == m_pPoints[2].m_PointX && m_pPoints[0].m_PointY == m_pPoints[2].m_PointY) ||
             (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX && m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-        return FALSE;
+        return false;
     }
     if (m_pPoints[0].m_PointX != m_pPoints[3].m_PointX && m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-        return FALSE;
+        return false;
     }
     for (int i = 1; i < 4; i ++) {
         if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-            return FALSE;
+            return false;
         }
         if (m_pPoints[i].m_PointX != m_pPoints[i - 1].m_PointX && m_pPoints[i].m_PointY != m_pPoints[i - 1].m_PointY) {
-            return FALSE;
+            return false;
         }
     }
     return m_PointCount == 5 || (m_pPoints[3].m_Flag & FXPT_CLOSEFIGURE);
 }
-FX_BOOL CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRect) const
+bool CFX_PathData::IsRect(const CFX_AffineMatrix* pMatrix, CFX_FloatRect* pRect) const
 {
     if (pMatrix == NULL) {
         if (!IsRect()) {
-            return FALSE;
+            return false;
         }
         if (pRect) {
             pRect->left = m_pPoints[0].m_PointX;
             pRect->right = m_pPoints[2].m_PointX;
             pRect->bottom = m_pPoints[0].m_PointY;
             pRect->top = m_pPoints[2].m_PointY;
             pRect->Normalize();
         }
-        return TRUE;
+        return true;
     }
     if (m_PointCount != 5 && m_PointCount != 4) {
-        return FALSE;
+        return false;
     }
     if ((m_PointCount == 5 && (m_pPoints[0].m_PointX != m_pPoints[4].m_PointX || m_pPoints[0].m_PointY != m_pPoints[4].m_PointY)) ||
             (m_pPoints[1].m_PointX == m_pPoints[3].m_PointX && m_pPoints[1].m_PointY == m_pPoints[3].m_PointY)) {
-        return FALSE;
+        return false;
     }
     if (m_PointCount == 4 && m_pPoints[0].m_PointX != m_pPoints[3].m_PointX && m_pPoints[0].m_PointY != m_pPoints[3].m_PointY) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT x[5], y[5];
     for (int i = 0; i < m_PointCount; i ++) {
         pMatrix->Transform(m_pPoints[i].m_PointX, m_pPoints[i].m_PointY, x[i], y[i]);
         if (i) {
             if ((m_pPoints[i].m_Flag & FXPT_TYPE) != FXPT_LINETO) {
-                return FALSE;
+                return false;
             }
             if (x[i] != x[i - 1] && y[i] != y[i - 1]) {
-                return FALSE;
+                return false;
             }
         }
     }
     if (pRect) {
         pRect->left = x[0];
         pRect->right = x[2];
         pRect->bottom = y[0];
         pRect->top = y[2];
         pRect->Normalize();
     }
-    return TRUE;
+    return true;
 }
 void CFX_PathData::Copy(const CFX_PathData &src)
 {
     SetPointCount(src.m_PointCount);
     FXSYS_memcpy(m_pPoints, src.m_pPoints, sizeof(FX_PATHPOINT) * m_PointCount);
 }
 CFX_GraphStateData::CFX_GraphStateData()
 {
     m_LineCap = LineCapButt;
     m_DashCount = 0;
@@ skipping 36 matching lines @@
     if (m_DashArray) {
         FX_Free(m_DashArray);
     }
     m_DashArray = NULL;
     m_DashCount = count;
     if (count == 0) {
         return;
     }
     m_DashArray = FX_Alloc(FX_FLOAT, count);
 }