FX_BOOL considered harmful.

core/include/fxcrt/fx_coordinates.h

 // 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
 
 #ifndef CORE_INCLUDE_FXCRT_FX_COORDINATES_H_
 #define CORE_INCLUDE_FXCRT_FX_COORDINATES_H_
 
 #include "fx_basic.h"
@@ skipping 50 matching lines @@
         x *= lamda;
         y *= lamda;
         return *this;
     }
     FXT_PSV&    operator /= (baseType lamda)
     {
         x /= lamda;
         y /= lamda;
         return *this;
     }
-    friend      FX_BOOL         operator == (const FXT_PSV &obj1, const FXT_PSV &obj2)
+    friend      bool            operator == (const FXT_PSV &obj1, const FXT_PSV &obj2)
     {
         return obj1.x == obj2.x && obj1.y == obj2.y;
     }
-    friend      FX_BOOL         operator != (const FXT_PSV &obj1, const FXT_PSV &obj2)
+    friend      bool            operator != (const FXT_PSV &obj1, const FXT_PSV &obj2)
     {
         return obj1.x != obj2.x || obj1.y != obj2.y;
     }
     friend      FXT_PSV         operator + (const FXT_PSV &obj1, const FXT_PSV &obj2)
     {
         CFX_PSVTemplate obj;
         obj.x = obj1.x + obj2.x;
         obj.y = obj1.y + obj2.y;
         return obj;
     }
@@ skipping 81 matching lines @@
         FXT_PSV::y = ((baseType)FXT_PSV::y) / fLen;
     }
     baseType    DotProduct(baseType otherx, baseType othery) const
     {
         return FXT_PSV::x * otherx + FXT_PSV::y * othery;
     }
     baseType    DotProduct(const FXT_VECTOR &v) const
     {
         return FXT_PSV::x * v.x + FXT_PSV::y * v.y;
     }
-    FX_BOOL             IsParallel(baseType otherx, baseType othery) const
+    bool                IsParallel(baseType otherx, baseType othery) const
     {
         baseType t = FXT_PSV::x * othery - FXT_PSV::y * otherx;
         return FXSYS_fabs(t) < 0x0001f;
     }
-    FX_BOOL             IsParallel(const FXT_VECTOR &v) const
+    bool                IsParallel(const FXT_VECTOR &v) const
     {
         return IsParallel(v.x, v.y);
     }
-    FX_BOOL             IsPerpendicular(baseType otherx, baseType othery) const
+    bool                IsPerpendicular(baseType otherx, baseType othery) const
     {
         baseType t = DotProduct(otherx, othery);
         return FXSYS_fabs(t) < 0x0001f;
     }
-    FX_BOOL             IsPerpendicular(const FXT_VECTOR &v) const
+    bool                IsPerpendicular(const FXT_VECTOR &v) const
     {
         return IsPerpendicular(v.x, v.y);
     }
     void                Translate(baseType dx, baseType dy)
     {
         FXT_PSV::x += dx, FXT_PSV::y += dy;
     }
     void                Scale(baseType sx, baseType sy)
     {
         FXT_PSV::x *= sx, FXT_PSV::y *= sy;
@@ skipping 131 matching lines @@
     {
         FXT_RECT::left += left;
         FXT_RECT::top += top;
         FXT_RECT::width -= left + right;
         FXT_RECT::height -= top + bottom;
     }
     void                Deflate(const FXT_RECT &rt)
     {
         Deflate(rt.left, rt.top, rt.top + rt.width, rt.top + rt.height);
     }
-    FX_BOOL             IsEmpty() const
+    bool                IsEmpty() const
     {
         return width <= 0 || height <= 0;
     }
-    FX_BOOL             IsEmpty(FX_FLOAT fEpsilon) const
+    bool                IsEmpty(FX_FLOAT fEpsilon) const
     {
         return width <= fEpsilon || height <= fEpsilon;
     }
     void                Empty()
     {
         width = height = 0;
     }
-    FX_BOOL             Contains(baseType x, baseType y) const
+    bool                Contains(baseType x, baseType y) const
     {
         return x >= left && x < left + width && y >= top && y < top + height;
     }
-    FX_BOOL             Contains(const FXT_POINT &p) const
+    bool                Contains(const FXT_POINT &p) const
     {
         return Contains(p.x, p.y);
     }
-    FX_BOOL             Contains(const FXT_RECT &rt) const
+    bool                Contains(const FXT_RECT &rt) const
     {
         return rt.left >= left && rt.right() <= right() && rt.top >= top && rt.bottom() <= bottom();
     }
     baseType    Width() const
     {
         return width;
     }
     baseType    Height() const
     {
         return height;
@@ skipping 120 matching lines @@
         }
         if (top < rt.top) {
             top = rt.top;
         }
         if (b > rt.bottom()) {
             b = rt.bottom();
         }
         width = r - left;
         height = b - top;
     }
-    FX_BOOL             IntersectWith(const FXT_RECT &rt) const
+    bool                IntersectWith(const FXT_RECT &rt) const
     {
         FXT_RECT rect = rt;
         rect.Intersect(*this);
         return !rect.IsEmpty();
     }
-    FX_BOOL             IntersectWith(const FXT_RECT &rt, FX_FLOAT fEpsilon) const
+    bool                IntersectWith(const FXT_RECT &rt, FX_FLOAT fEpsilon) const
     {
         FXT_RECT rect = rt;
         rect.Intersect(*this);
         return !rect.IsEmpty(fEpsilon);
     }
-    friend      FX_BOOL operator == (const FXT_RECT &rc1, const FXT_RECT &rc2)
+    friend      bool    operator == (const FXT_RECT &rc1, const FXT_RECT &rc2)
     {
         return rc1.left == rc2.left && rc1.top == rc2.top && rc1.width == rc2.width && rc1.height == rc2.height;
     }
-    friend      FX_BOOL operator != (const FXT_RECT &rc1, const FXT_RECT &rc2)
+    friend      bool    operator != (const FXT_RECT &rc1, const FXT_RECT &rc2)
     {
         return rc1.left != rc2.left || rc1.top != rc2.top || rc1.width != rc2.width || rc1.height != rc2.height;
     }
     baseType left, top;
     baseType width, height;
 };
 typedef CFX_RTemplate<int32_t>                  CFX_Rect;
 typedef CFX_RTemplate<FX_FLOAT>                 CFX_RectF;
 typedef CFX_RTemplate<int32_t> *                FX_LPRECT;
 typedef CFX_RTemplate<FX_FLOAT> *               FX_LPRECTF;
@@ skipping 23 matching lines @@
     int                 Width() const
     {
         return right - left;
     }
 
     int                 Height() const
     {
         return bottom - top;
     }
 
-    FX_BOOL             IsEmpty() const
+    bool                IsEmpty() const
     {
         return right <= left || bottom <= top;
     }
 
     void                Normalize();
 
     void                Intersect(const FX_RECT& src);
 
     void                Intersect(int left1, int top1, int right1, int bottom1)
     {
         Intersect(FX_RECT(left1, top1, right1, bottom1));
     }
 
     void                Union(const FX_RECT& other_rect);
 
-    FX_BOOL             operator == (const FX_RECT& src) const
+    bool                operator == (const FX_RECT& src) const
     {
         return left == src.left && right == src.right && top == src.top && bottom == src.bottom;
     }
 
     void                Offset(int dx, int dy)
     {
         left += dx;
         right += dx;
         top += dy;
         bottom += dy;
     }
 
-    FX_BOOL             Contains(const FX_RECT& other_rect) const
+    bool                Contains(const FX_RECT& other_rect) const
     {
         return other_rect.left >= left && other_rect.right <= right && other_rect.top >= top && other_rect.bottom <= bottom;
     }
 
-    FX_BOOL             Contains(int x, int y) const
+    bool                Contains(int x, int y) const
     {
         return x >= left && x < right && y >= top && y < bottom;
     }
 };
 struct FX_SMALL_RECT {
 
     int16_t     Left;
 
     int16_t     Top;
 
@@ skipping 21 matching lines @@
     CFX_FloatRect(const FX_FLOAT* pArray)
     {
         left = pArray[0];
         bottom = pArray[1];
         right = pArray[2];
         top = pArray[3];
     }
 
     CFX_FloatRect(const FX_RECT& rect);
 
-    FX_BOOL                             IsEmpty() const
+    bool                                IsEmpty() const
     {
         return left >= right || bottom >= top;
     }
 
     void                                Normalize();
 
     void                                Reset()
     {
         left = right = bottom = top = 0;
     }
 
-    FX_BOOL                             Contains(const CFX_FloatRect& other_rect) const;
+    bool                                Contains(const CFX_FloatRect& other_rect) const;
 
-    FX_BOOL                             Contains(FX_FLOAT x, FX_FLOAT y) const;
+    bool                                Contains(FX_FLOAT x, FX_FLOAT y) const;
 
     void                                Transform(const CFX_Matrix* pMatrix);
 
     void                                Intersect(const CFX_FloatRect& other_rect);
 
     void                                Union(const CFX_FloatRect& other_rect);
 
     FX_RECT                             GetInnerRect() const;
 
     FX_RECT                             GetOutterRect() const;
@@ skipping 114 matching lines @@
     void                        Set(const FX_FLOAT n[6]);
 
     void                        SetIdentity()
     {
         a = d = 1;
         b = c = e = f = 0;
     }
 
     void                        SetReverse(const CFX_Matrix &m);
 
-    void                        Concat(FX_FLOAT a, FX_FLOAT b, FX_FLOAT c, FX_FLOAT d, FX_FLOAT e, FX_FLOAT f, FX_BOOL bPrepended = FALSE);
+    void                        Concat(FX_FLOAT a, FX_FLOAT b, FX_FLOAT c, FX_FLOAT d, FX_FLOAT e, FX_FLOAT f, bool bPrepended = false);
 
-    void                        Concat(const CFX_Matrix &m, FX_BOOL bPrepended = FALSE);
+    void                        Concat(const CFX_Matrix &m, bool bPrepended = false);
 
-    void                        ConcatInverse(const CFX_Matrix& m, FX_BOOL bPrepended = FALSE);
+    void                        ConcatInverse(const CFX_Matrix& m, bool bPrepended = false);
     void                        Reset()
     {
         SetIdentity();
     }
 
     void                        Copy(const CFX_Matrix& m)
     {
         *this = m;
     }
 
-    FX_BOOL                     IsIdentity() const
+    bool                        IsIdentity() const
     {
         return a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0;
     }
-    FX_BOOL                     IsInvertible() const;
+    bool                        IsInvertible() const;
 
-    FX_BOOL                     Is90Rotated() const;
+    bool                        Is90Rotated() const;
 
-    FX_BOOL                     IsScaled() const;
+    bool                        IsScaled() const;
 
-    void                        Translate(FX_FLOAT x, FX_FLOAT y, FX_BOOL bPrepended = FALSE);
+    void                        Translate(FX_FLOAT x, FX_FLOAT y, bool bPrepended = false);
 
-    void                        TranslateI(int32_t x, int32_t y, FX_BOOL bPrepended = FALSE)
+    void                        TranslateI(int32_t x, int32_t y, bool bPrepended = false)
     {
         Translate((FX_FLOAT)x, (FX_FLOAT)y, bPrepended);
     }
 
-    void                        Scale(FX_FLOAT sx, FX_FLOAT sy, FX_BOOL bPrepended = FALSE);
+    void                        Scale(FX_FLOAT sx, FX_FLOAT sy, bool bPrepended = false);
 
-    void                        Rotate(FX_FLOAT fRadian, FX_BOOL bPrepended = FALSE);
+    void                        Rotate(FX_FLOAT fRadian, bool bPrepended = false);
 
-    void                        RotateAt(FX_FLOAT fRadian, FX_FLOAT x, FX_FLOAT y, FX_BOOL bPrepended = FALSE);
+    void                        RotateAt(FX_FLOAT fRadian, FX_FLOAT x, FX_FLOAT y, bool bPrepended = false);
 
-    void                        Shear(FX_FLOAT fAlphaRadian, FX_FLOAT fBetaRadian, FX_BOOL bPrepended = FALSE);
+    void                        Shear(FX_FLOAT fAlphaRadian, FX_FLOAT fBetaRadian, bool bPrepended = false);
 
     void                        MatchRect(const CFX_FloatRect &dest, const CFX_FloatRect &src);
 
     FX_FLOAT            GetXUnit() const;
 
     FX_FLOAT            GetYUnit() const;
     void                        GetUnitRect(CFX_RectF &rect) const;
 
     CFX_FloatRect       GetUnitRect() const;
 
@@ skipping 66 matching lines @@
     FX_FLOAT a;
     FX_FLOAT b;
     FX_FLOAT c;
     FX_FLOAT d;
     FX_FLOAT e;
     FX_FLOAT f;
 };
 #define CFX_AffineMatrix        CFX_Matrix
 
 #endif  // CORE_INCLUDE_FXCRT_FX_COORDINATES_H_