FX_BOOL considered harmful.

core/src/fpdfapi/fpdf_render/fpdf_render_pattern.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 "../../../include/fpdfapi/fpdf_render.h"
 #include "../../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../fpdf_page/pageint.h"
@@ skipping 11 matching lines @@
     FX_FLOAT start_x = pCoords->GetNumber(0);
     FX_FLOAT start_y = pCoords->GetNumber(1);
     FX_FLOAT end_x = pCoords->GetNumber(2);
     FX_FLOAT end_y = pCoords->GetNumber(3);
     FX_FLOAT t_min = 0, t_max = 1.0f;
     CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Domain"));
     if (pArray) {
         t_min = pArray->GetNumber(0);
         t_max = pArray->GetNumber(1);
     }
-    FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
+    bool bStartExtend = false, bEndExtend = false;
     pArray = pDict->GetArray(FX_BSTRC("Extend"));
     if (pArray) {
         bStartExtend = pArray->GetInteger(0);
         bEndExtend = pArray->GetInteger(1);
     }
     int width = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     FX_FLOAT x_span = end_x - start_x;
     FX_FLOAT y_span = end_y - start_y;
     FX_FLOAT axis_len_square = FXSYS_Mul(x_span, x_span) + FXSYS_Mul(y_span, y_span);
@@ skipping 66 matching lines @@
     FX_FLOAT end_y = pCoords->GetNumber(4);
     FX_FLOAT end_r = pCoords->GetNumber(5);
     CFX_AffineMatrix matrix;
     matrix.SetReverse(*pObject2Bitmap);
     FX_FLOAT t_min = 0, t_max = 1.0f;
     CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Domain"));
     if (pArray) {
         t_min = pArray->GetNumber(0);
         t_max = pArray->GetNumber(1);
     }
-    FX_BOOL bStartExtend = FALSE, bEndExtend = FALSE;
+    bool bStartExtend = false, bEndExtend = false;
     pArray = pDict->GetArray(FX_BSTRC("Extend"));
     if (pArray) {
         bStartExtend = pArray->GetInteger(0);
         bEndExtend = pArray->GetInteger(1);
     }
     int total_results = 0;
     for (int j = 0; j < nFuncs; j ++) {
         if (pFuncs[j]) {
             total_results += pFuncs[j]->CountOutputs();
         }
@@ skipping 18 matching lines @@
         }
         FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
         pCS->GetRGB(pResults, R, G, B);
         rgb_array[i] = FXARGB_TODIB(FXARGB_MAKE(alpha, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255)));
     }
     FX_FLOAT a = FXSYS_Mul(start_x - end_x, start_x - end_x) +
                  FXSYS_Mul(start_y - end_y, start_y - end_y) - FXSYS_Mul(start_r - end_r, start_r - end_r);
     int width = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     int pitch = pBitmap->GetPitch();
-    FX_BOOL bDecreasing = FALSE;
+    bool bDecreasing = false;
     if (start_r > end_r) {
         int length = (int)FXSYS_sqrt((FXSYS_Mul(start_x - end_x, start_x - end_x) + FXSYS_Mul(start_y - end_y, start_y - end_y)));
         if (length < start_r - end_r) {
-            bDecreasing = TRUE;
+            bDecreasing = true;
         }
     }
     for (int row = 0; row < height; row ++) {
         FX_DWORD* dib_buf = (FX_DWORD*)(pBitmap->GetBuffer() + row * pitch);
         for (int column = 0; column < width; column ++) {
             FX_FLOAT x = (FX_FLOAT)column, y = (FX_FLOAT)row;
             matrix.Transform(x, y);
             FX_FLOAT b = -2 * (FXSYS_Mul(x - start_x, end_x - start_x) + FXSYS_Mul(y - start_y, end_y - start_y) +
                                FXSYS_Mul(start_r, end_r - start_r));
             FX_FLOAT c = FXSYS_Mul(x - start_x, x - start_x) + FXSYS_Mul(y - start_y, y - start_y) -
@@ skipping 101 matching lines @@
                         offset += nresults;
                     }
                 }
             }
             FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
             pCS->GetRGB(pResults, R, G, B);
             dib_buf[column] = FXARGB_TODIB(FXARGB_MAKE(alpha, (int32_t)(R * 255), (int32_t)(G * 255), (int32_t)(B * 255)));
         }
     }
 }
-FX_BOOL _GetScanlineIntersect(int y, FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_FLOAT& x)
+bool _GetScanlineIntersect(int y, FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_FLOAT& x)
 {
     if (y1 == y2) {
-        return FALSE;
+        return false;
     }
     if (y1 < y2) {
         if (y < y1 || y > y2) {
-            return FALSE;
+            return false;
         }
     } else {
         if (y < y2 || y > y1) {
-            return FALSE;
+            return false;
         }
     }
     x = x1 + FXSYS_MulDiv(x2 - x1, y - y1, y2 - y1);
-    return TRUE;
+    return true;
 }
 static void _DrawGouraud(CFX_DIBitmap* pBitmap, int alpha, CPDF_MeshVertex triangle[3])
 {
     FX_FLOAT min_y = triangle[0].y, max_y = triangle[0].y;
     for (int i = 1; i < 3; i ++) {
         if (min_y > triangle[i].y) {
             min_y = triangle[i].y;
         }
         if (max_y < triangle[i].y) {
             max_y = triangle[i].y;
         }
     }
     if (min_y == max_y) {
         return;
     }
     int min_yi = (int)FXSYS_floor(min_y), max_yi = (int)FXSYS_ceil(max_y);
     if (min_yi < 0) {
         min_yi = 0;
     }
     if (max_yi >= pBitmap->GetHeight()) {
         max_yi = pBitmap->GetHeight() - 1;
     }
     for (int y = min_yi; y <= max_yi; y ++) {
         int nIntersects = 0;
         FX_FLOAT inter_x[3], r[3], g[3], b[3];
         for (int i = 0; i < 3; i ++) {
             CPDF_MeshVertex& vertex1 = triangle[i];
             CPDF_MeshVertex& vertex2 = triangle[(i + 1) % 3];
-            FX_BOOL bIntersect = _GetScanlineIntersect(y, vertex1.x, vertex1.y,
+            bool bIntersect = _GetScanlineIntersect(y, vertex1.x, vertex1.y,
                                  vertex2.x, vertex2.y, inter_x[nIntersects]);
             if (!bIntersect) {
                 continue;
             }
             r[nIntersects] = vertex1.r + FXSYS_MulDiv(vertex2.r - vertex1.r, y - vertex1.y, vertex2.y - vertex1.y);
             g[nIntersects] = vertex1.g + FXSYS_MulDiv(vertex2.g - vertex1.g, y - vertex1.y, vertex2.y - vertex1.y);
             b[nIntersects] = vertex1.b + FXSYS_MulDiv(vertex2.b - vertex1.b, y - vertex1.y, vertex2.y - vertex1.y);
             nIntersects ++;
         }
         if (nIntersects != 2) {
@@ skipping 255 matching lines @@
 };
 struct CPDF_PatchDrawer {
     Coon_Color                  patch_colors[4];
     int                                 max_delta;
     CFX_PathData                path;
     CFX_RenderDevice*   pDevice;
     int                                 fill_mode;
     int                                 alpha;
     void Draw(int x_scale, int y_scale, int left, int bottom, Coon_Bezier C1, Coon_Bezier C2, Coon_Bezier D1, Coon_Bezier D2)
     {
-        FX_BOOL bSmall = C1.Distance() < 2 && C2.Distance() < 2 && D1.Distance() < 2 && D2.Distance() < 2;
+        bool bSmall = C1.Distance() < 2 && C2.Distance() < 2 && D1.Distance() < 2 && D2.Distance() < 2;
         Coon_Color div_colors[4];
         int d_bottom, d_left, d_top, d_right;
         div_colors[0].BiInterpol(patch_colors, left, bottom, x_scale, y_scale);
         if (!bSmall) {
             div_colors[1].BiInterpol(patch_colors, left, bottom + 1, x_scale, y_scale);
             div_colors[2].BiInterpol(patch_colors, left + 1, bottom + 1, x_scale, y_scale);
             div_colors[3].BiInterpol(patch_colors, left + 1, bottom, x_scale, y_scale);
             d_bottom = div_colors[3].Distance(div_colors[0]);
             d_left = div_colors[1].Distance(div_colors[0]);
             d_top = div_colors[1].Distance(div_colors[2]);
@@ skipping 41 matching lines @@
                 bottom *= 2;
                 Draw(x_scale, y_scale, left, bottom, C1.first_half(), m1f, D1.first_half(), m2f);
                 Draw(x_scale, y_scale, left, bottom + 1, m1f, C2.first_half(), D1.second_half(), m2s);
                 Draw(x_scale, y_scale, left + 1, bottom, C1.second_half(), m1s, m2f, D2.first_half());
                 Draw(x_scale, y_scale, left + 1, bottom + 1, m1s, C2.second_half(), m2s, D2.second_half());
             }
         }
     }
 };
 
-FX_BOOL _CheckCoonTensorPara(const CPDF_MeshStream &stream)
+bool _CheckCoonTensorPara(const CPDF_MeshStream &stream)
 {
-    FX_BOOL bCoorBits = ( stream.m_nCoordBits== 1   ||
+    bool bCoorBits = ( stream.m_nCoordBits== 1   ||
                           stream.m_nCoordBits == 2  ||
                           stream.m_nCoordBits == 4  ||
                           stream.m_nCoordBits == 8  ||
                           stream.m_nCoordBits == 12 ||
                           stream.m_nCoordBits == 16 ||
                           stream.m_nCoordBits == 24 ||
                           stream.m_nCoordBits == 32   );
 
-    FX_BOOL bCompBits = ( stream.m_nCompBits == 1  ||
+    bool bCompBits = ( stream.m_nCompBits == 1  ||
                           stream.m_nCompBits == 2  ||
                           stream.m_nCompBits == 4  ||
                           stream.m_nCompBits == 8  ||
                           stream.m_nCompBits == 12 ||
                           stream.m_nCompBits == 16   );
 
-    FX_BOOL bFlagBits = ( stream.m_nFlagBits == 2  ||
+    bool bFlagBits = ( stream.m_nFlagBits == 2  ||
                           stream.m_nFlagBits == 4  ||
                           stream.m_nFlagBits == 8    );
 
     return bCoorBits && bCompBits && bFlagBits;
 }
 
-static void _DrawCoonPatchMeshes(FX_BOOL bTensor, CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2Bitmap,
+static void _DrawCoonPatchMeshes(bool bTensor, CFX_DIBitmap* pBitmap, CFX_AffineMatrix* pObject2Bitmap,
                                  CPDF_Stream* pShadingStream, CPDF_Function** pFuncs, int nFuncs,
                                  CPDF_ColorSpace* pCS, int fill_mode, int alpha)
 {
     ASSERT(pBitmap->GetFormat() == FXDIB_Argb);
     if (pShadingStream->GetType() != PDFOBJ_STREAM) {
         return;
     }
     CFX_FxgeDevice device;
     device.Attach(pBitmap);
     CPDF_MeshStream stream;
@@ skipping 59 matching lines @@
         C2.FromPoints(coords[3].x, coords[3].y, coords[4].x, coords[4].y, coords[5].x, coords[5].y,
                       coords[6].x, coords[6].y);
         D1.FromPoints(coords[0].x, coords[0].y, coords[1].x, coords[1].y, coords[2].x, coords[2].y,
                       coords[3].x, coords[3].y);
         D2.FromPoints(coords[9].x, coords[9].y, coords[8].x, coords[8].y, coords[7].x, coords[7].y,
                       coords[6].x, coords[6].y);
         patch.Draw(1, 1, 0, 0, C1, C2, D1, D2);
     }
 }
 void CPDF_RenderStatus::DrawShading(CPDF_ShadingPattern* pPattern, CFX_AffineMatrix* pMatrix,
-                                    FX_RECT& clip_rect, int alpha, FX_BOOL bAlphaMode)
+                                    FX_RECT& clip_rect, int alpha, bool bAlphaMode)
 {
     CPDF_Function** pFuncs = pPattern->m_pFunctions;
     int nFuncs = pPattern->m_nFuncs;
     CPDF_Dictionary* pDict = pPattern->m_pShadingObj->GetDict();
     CPDF_ColorSpace* pColorSpace = pPattern->m_pCS;
     if (pColorSpace == NULL) {
         return;
     }
     FX_ARGB background = 0;
     if (!pPattern->m_bShadingObj && pPattern->m_pShadingObj->GetDict()->KeyExist(FX_BSTRC("Background"))) {
@@ skipping 51 matching lines @@
             break;
     }
     if (bAlphaMode) {
         pBitmap->LoadChannel(FXDIB_Red, pBitmap, FXDIB_Alpha);
     }
     if (m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
         pBitmap->ConvertColorScale(m_Options.m_ForeColor, m_Options.m_BackColor);
     }
     buffer.OutputToDevice();
 }
-void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawShadingPattern(CPDF_ShadingPattern* pattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke)
 {
     if (!pattern->Load()) {
         return;
     }
     m_pDevice->SaveState();
     if (pPageObj->m_Type == PDFPAGE_PATH) {
         if (!SelectClipPath((CPDF_PathObject*)pPageObj, pObj2Device, bStroke)) {
             m_pDevice->RestoreState();
             return;
         }
     } else if (pPageObj->m_Type == PDFPAGE_IMAGE) {
         FX_RECT rect = pPageObj->GetBBox(pObj2Device);
         m_pDevice->SetClip_Rect(&rect);
     } else {
         return;
     }
     FX_RECT rect;
-    if (GetObjectClippedRect(pPageObj, pObj2Device, FALSE, rect)) {
+    if (GetObjectClippedRect(pPageObj, pObj2Device, false, rect)) {
         m_pDevice->RestoreState();
         return;
     }
     CFX_AffineMatrix matrix = pattern->m_Pattern2Form;
     matrix.Concat(*pObj2Device);
     GetScaledMatrix(matrix);
     int alpha = pPageObj->m_GeneralState.GetAlpha(bStroke);
     DrawShading(pattern, &matrix, rect, alpha, m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
     m_pDevice->RestoreState();
 }
-FX_BOOL CPDF_RenderStatus::ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device)
+bool CPDF_RenderStatus::ProcessShading(CPDF_ShadingObject* pShadingObj, const CFX_AffineMatrix* pObj2Device)
 {
     FX_RECT rect = pShadingObj->GetBBox(pObj2Device);
     FX_RECT clip_box = m_pDevice->GetClipBox();
     rect.Intersect(clip_box);
     if (rect.IsEmpty()) {
-        return TRUE;
+        return true;
     }
     CFX_AffineMatrix matrix = pShadingObj->m_Matrix;
     matrix.Concat(*pObj2Device);
-    DrawShading(pShadingObj->m_pShading, &matrix, rect, pShadingObj->m_GeneralState.GetAlpha(FALSE),
+    DrawShading(pShadingObj->m_pShading, &matrix, rect, pShadingObj->m_GeneralState.GetAlpha(false),
                 m_Options.m_ColorMode == RENDER_COLOR_ALPHA);
-    return TRUE;
+    return true;
 }
 static CFX_DIBitmap* DrawPatternBitmap(CPDF_Document* pDoc, CPDF_PageRenderCache* pCache,
                                        CPDF_TilingPattern* pPattern, const CFX_AffineMatrix* pObject2Device,
                                        int width, int height, int flags)
 {
     CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
     if (!pBitmap->Create(width, height, pPattern->m_bColored ? FXDIB_Argb : FXDIB_8bppMask)) {
         delete pBitmap;
         return NULL;
     }
@@ skipping 12 matching lines @@
     if (!pPattern->m_bColored) {
         options.m_ColorMode = RENDER_COLOR_ALPHA;
     }
     flags |= RENDER_FORCE_HALFTONE;
     options.m_Flags = flags;
     CPDF_RenderContext context;
     context.Create(pDoc, pCache, NULL);
     context.DrawObjectList(&bitmap_device, pPattern->m_pForm, &mtPattern2Bitmap, &options);
     return pBitmap;
 }
-void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawTilingPattern(CPDF_TilingPattern* pPattern, CPDF_PageObject* pPageObj, const CFX_AffineMatrix* pObj2Device, bool bStroke)
 {
     if (!pPattern->Load()) {
         return;
     }
     m_pDevice->SaveState();
     if (pPageObj->m_Type == PDFPAGE_PATH) {
         if (!SelectClipPath((CPDF_PathObject*)pPageObj, pObj2Device, bStroke)) {
             m_pDevice->RestoreState();
             return;
         }
     } else if (pPageObj->m_Type == PDFPAGE_IMAGE) {
         FX_RECT rect = pPageObj->GetBBox(pObj2Device);
         m_pDevice->SetClip_Rect(&rect);
     } else {
         return;
     }
     FX_RECT clip_box = m_pDevice->GetClipBox();
     if (clip_box.IsEmpty()) {
         m_pDevice->RestoreState();
         return;
     }
     CFX_Matrix dCTM = m_pDevice->GetCTM();
     FX_FLOAT sa = FXSYS_fabs(dCTM.a);
     FX_FLOAT sd = FXSYS_fabs(dCTM.d);
     clip_box.right = clip_box.left + (int32_t)FXSYS_ceil(clip_box.Width() * sa);
     clip_box.bottom = clip_box.top + (int32_t)FXSYS_ceil(clip_box.Height() * sd);
     CFX_AffineMatrix mtPattern2Device = pPattern->m_Pattern2Form;
     mtPattern2Device.Concat(*pObj2Device);
     GetScaledMatrix(mtPattern2Device);
-    FX_BOOL bAligned = FALSE;
+    bool bAligned = false;
     if (pPattern->m_BBox.left == 0 && pPattern->m_BBox.bottom == 0 &&
             pPattern->m_BBox.right == pPattern->m_XStep && pPattern->m_BBox.top == pPattern->m_YStep &&
             (mtPattern2Device.IsScaled() || mtPattern2Device.Is90Rotated())) {
-        bAligned = TRUE;
+        bAligned = true;
     }
     CFX_FloatRect cell_bbox = pPattern->m_BBox;
     mtPattern2Device.TransformRect(cell_bbox);
     int width = (int)FXSYS_ceil(cell_bbox.Width());
     int height = (int)FXSYS_ceil(cell_bbox.Height());
     if (width == 0) {
         width = 1;
     }
     if (height == 0) {
         height = 1;
@@ skipping 106 matching lines @@
                 }
             } else {
                 if (pPattern->m_bColored) {
                     screen.CompositeBitmap(start_x, start_y, width, height, pPatternBitmap, 0, 0);
                 } else {
                     screen.CompositeMask(start_x, start_y, width, height, pPatternBitmap, fill_argb, 0, 0);
                 }
             }
         }
     }
-    CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255, FXDIB_BLEND_NORMAL, FALSE);
+    CompositeDIBitmap(&screen, clip_box.left, clip_box.top, 0, 255, FXDIB_BLEND_NORMAL, false);
     m_pDevice->RestoreState();
     delete pPatternBitmap;
 }
-void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, FX_BOOL bStroke)
+void CPDF_RenderStatus::DrawPathWithPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, CPDF_Color* pColor, bool bStroke)
 {
     CPDF_Pattern* pattern = pColor->GetPattern();
     if (pattern == NULL) {
         return;
     }
     if(pattern->m_PatternType == PATTERN_TILING) {
         DrawTilingPattern((CPDF_TilingPattern*)pattern, pPathObj, pObj2Device, bStroke);
     } else {
         DrawShadingPattern((CPDF_ShadingPattern*)pattern, pPathObj, pObj2Device, bStroke);
     }
 }
-void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, FX_BOOL& bStroke)
+void CPDF_RenderStatus::ProcessPathPattern(CPDF_PathObject* pPathObj, const CFX_AffineMatrix* pObj2Device, int& filltype, bool& bStroke)
 {
     if(filltype) {
         CPDF_Color& FillColor = *pPathObj->m_ColorState.GetFillColor();
         if(FillColor.m_pCS && FillColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
-            DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, FALSE);
+            DrawPathWithPattern(pPathObj, pObj2Device, &FillColor, false);
             filltype = 0;
         }
     }
     if(bStroke) {
         CPDF_Color& StrokeColor = *pPathObj->m_ColorState.GetStrokeColor();
         if(StrokeColor.m_pCS && StrokeColor.m_pCS->GetFamily() == PDFCS_PATTERN) {
-            DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, TRUE);
-            bStroke = FALSE;
+            DrawPathWithPattern(pPathObj, pObj2Device, &StrokeColor, true);
+            bStroke = false;
         }
     }
 }