FX_BOOL considered harmful.

core/src/fxge/apple/fx_quartz_device.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/fxcrt/fx_ext.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../agg/include/fx_agg_driver.h"
@@ skipping 58 matching lines @@
     }
     CGContextRef context = (CGContextRef) graphics;
     CGFloat ty = CGBitmapContextGetHeight(context) - matrix->f;
     CGContextSetTextMatrix(context, CGAffineTransformMake(matrix->a,
                            matrix->b,
                            matrix->c,
                            matrix->d,
                            matrix->e,
                            ty));
 }
-FX_BOOL CQuartz2D::drawGraphicsString(void*                 graphics,
+bool CQuartz2D::drawGraphicsString(void*                 graphics,
                                       void*                 font,
                                       FX_FLOAT              fontSize,
                                       FX_WORD*              glyphIndices,
                                       CGPoint*           glyphPositions,
                                       int32_t              charsCount,
                                       FX_ARGB               argb,
                                       CFX_AffineMatrix*     matrix )
 {
     if (!graphics) {
-        return FALSE;
+        return false;
     }
     CGContextRef context = (CGContextRef) graphics;
     CGContextSetFont(context, (CGFontRef)font);
     CGContextSetFontSize(context, fontSize);
     if (matrix) {
         CGAffineTransform m = CGContextGetTextMatrix(context);
         m = CGAffineTransformConcat(m,
                                     CGAffineTransformMake(matrix->a,
                                             matrix->b,
                                             matrix->c,
                                             matrix->d,
                                             matrix->e,
                                             matrix->f));
         CGContextSetTextMatrix(context, m);
     }
     int32_t a, r, g, b;
     ArgbDecode(argb, a, r, g, b);
     CGContextSetRGBFillColor(context,
                              r / 255.f,
                              g / 255.f,
                              b / 255.f,
                              a / 255.f);
     CGContextSaveGState(context);
 #if CGFLOAT_IS_DOUBLE
     CGPoint* glyphPositionsCG = new CGPoint[charsCount];
     if (!glyphPositionsCG) {
-        return FALSE;
+        return false;
     }
     for (int index = 0; index < charsCount; ++index) {
         glyphPositionsCG[index].x = glyphPositions[index].x;
         glyphPositionsCG[index].y = glyphPositions[index].y;
     }
 #else
     CGPoint* glyphPositionsCG = (CGPoint*)glyphPositions;
 #endif
     CGContextShowGlyphsAtPositions(context,
                                    (CGGlyph *) glyphIndices,
                                    glyphPositionsCG,
                                    charsCount);
 #if CGFLOAT_IS_DOUBLE
     delete[] glyphPositionsCG;
 #endif
     CGContextRestoreGState(context);
-    return TRUE;
+    return true;
 }
 void CQuartz2D::saveGraphicsState(void * graphics)
 {
     if (graphics) {
         CGContextSaveGState((CGContextRef) graphics);
     }
 }
 void CQuartz2D::restoreGraphicsState(void * graphics)
 {
     if (graphics) {
@@ skipping 100 matching lines @@
 CFX_Matrix CFX_QuartzDeviceDriver::GetCTM() const
 {
     CGAffineTransform ctm = CGContextGetCTM(_context);
     return CFX_Matrix(ctm.a, ctm.b, ctm.c, ctm.d, ctm.tx, ctm.ty);
 }
 void CFX_QuartzDeviceDriver::SaveState()
 {
     CGContextSaveGState(_context);
     m_saveCount++;
 }
-void CFX_QuartzDeviceDriver::RestoreState(FX_BOOL isKeepSaved )
+void CFX_QuartzDeviceDriver::RestoreState(bool isKeepSaved )
 {
     CGContextRestoreGState(_context);
     if (isKeepSaved) {
         CGContextSaveGState(_context);
     } else {
         m_saveCount--;
     }
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData*    pathData,
+bool CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData*    pathData,
         const CFX_AffineMatrix*   matrix,
         int                       fillMode )
 {
     SaveState();
     CGAffineTransform m = CGAffineTransformIdentity;
     if (matrix) {
         m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(), matrix->GetD(), matrix->GetE(), matrix->GetF());
     }
     m = CGAffineTransformConcat(m, _foxitDevice2User);
     CGContextConcatCTM(_context, m);
     setPathToContext(pathData);
-    RestoreState(FALSE);
+    RestoreState(false);
     if ((fillMode & 3) == FXFILL_WINDING) {
         CGContextClip(_context);
     } else {
         CGContextEOClip(_context);
     }
-    return TRUE;
+    return true;
 }
 FX_FLOAT CFX_QuartzDeviceDriver::getLineWidth(const CFX_GraphStateData * graphState, CGAffineTransform ctm)
 {
     FX_FLOAT lineWidth = graphState->m_LineWidth;
     if (graphState->m_LineWidth <= 0.f) {
         CGSize size;
         size.width = 1;
         size.height = 1;
         CGSize temp = CGSizeApplyAffineTransform(size, ctm);
         CGFloat x = 1 / temp.width;
         CGFloat y = 1 / temp.height;
         lineWidth = x > y ? x : y;
     }
     return lineWidth;
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData*      pathData,
+bool CFX_QuartzDeviceDriver::SetClip_PathStroke(const CFX_PathData*      pathData,
         const CFX_AffineMatrix*     matrix,
         const CFX_GraphStateData*   graphState )
 {
     SaveState();
     CGAffineTransform m = CGAffineTransformIdentity;
     if (matrix) {
         m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(), matrix->GetD(), matrix->GetE(), matrix->GetF());
     }
     m = CGAffineTransformConcat(m, _foxitDevice2User);
     CGContextConcatCTM(_context, m);
     FX_FLOAT lineWidth = getLineWidth(graphState, m);
     setStrokeInfo(graphState, 0xFF000000, lineWidth);
     setPathToContext(pathData);
     CGContextReplacePathWithStrokedPath(_context);
-    RestoreState(FALSE);
+    RestoreState(false);
     CGContextClip(_context);
-    return TRUE;
+    return true;
 }
 static CGBlendMode GetCGBlendMode(int blend_type)
 {
     CGBlendMode mode = kCGBlendModeNormal;
     switch (blend_type) {
         case FXDIB_BLEND_NORMAL:
             mode = kCGBlendModeNormal;
             break;
         case FXDIB_BLEND_MULTIPLY:
             mode = kCGBlendModeMultiply;
@@ skipping 39 matching lines @@
             break;
         case FXDIB_BLEND_LUMINOSITY:
             mode = kCGBlendModeLuminosity;
             break;
         default:
             mode = kCGBlendModeNormal;
             break;
     }
     return mode;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData*        pathData,
+bool CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData*        pathData,
         const CFX_AffineMatrix*       matrix,
         const CFX_GraphStateData*     graphState,
         FX_DWORD                      fillArgb,
         FX_DWORD                      strokeArgb,
         int                           fillMode,
         int                           alpha_flag,
         void*                         pIccTransform,
         int                                                     blend_type
                                         )
 {
@@ skipping 31 matching lines @@
         CGContextStrokePath(_context);
     } else if (pathMode == 1) {
         CGContextFillPath(_context);
     } else if (pathMode == 2) {
         CGContextEOFillPath(_context);
     } else if (pathMode == 5) {
         CGContextDrawPath(_context, kCGPathFillStroke);
     } else if (pathMode == 6) {
         CGContextDrawPath(_context, kCGPathEOFillStroke);
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::FillRect(const FX_RECT*         rect,
+bool CFX_QuartzDeviceDriver::FillRect(const FX_RECT*         rect,
         FX_ARGB                   fillArgb,
         int                       alphaFlag        ,
         void*                     iccTransform ,
         int                                             blend_type )
 {
     CGBlendMode mode = GetCGBlendMode(blend_type);
     if (mode != kCGBlendModeNormal) {
         CGContextSetBlendMode(_context, mode);
     }
     CGRect rect_fx = CGRectMake(rect->left, rect->top, rect->Width(), rect->Height());
     CGRect rect_usr = CGRectApplyAffineTransform(rect_fx, _foxitDevice2User);
     int32_t a, r, g, b;
     ArgbDecode(fillArgb, a, r, g, b);
     CGContextSetRGBFillColor(_context,
                              r / 255.f,
                              g / 255.f,
                              b / 255.f,
                              a / 255.f);
     CGContextFillRect(_context, rect_usr);
     if (mode != kCGBlendModeNormal) {
         CGContextSetBlendMode(_context, kCGBlendModeNormal);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT           x1,
+bool CFX_QuartzDeviceDriver::DrawCosmeticLine(FX_FLOAT           x1,
         FX_FLOAT              y1,
         FX_FLOAT              x2,
         FX_FLOAT              y2,
         FX_DWORD              argb,
         int                   alphaFlag       ,
         void*                 iccTransform    ,
         int                                     blend_type )
 {
     CGBlendMode mode = GetCGBlendMode(blend_type);
     if (mode != kCGBlendModeNormal) {
@@ skipping 11 matching lines @@
                                r / 255.f,
                                g / 255.f,
                                b / 255.f,
                                a / 255.f);
     CGContextMoveToPoint(_context, x1, y1);
     CGContextAddLineToPoint(_context, x2, y2);
     CGContextStrokePath(_context);
     if (mode != kCGBlendModeNormal) {
         CGContextSetBlendMode(_context, kCGBlendModeNormal);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect)
+bool CFX_QuartzDeviceDriver::GetClipBox(FX_RECT* rect)
 {
     CGRect r = CGContextGetClipBoundingBox(_context);
     r = CGRectApplyAffineTransform(r, _user2FoxitDevice);
     rect->left          = FXSYS_floor(r.origin.x);
     rect->top           = FXSYS_floor(r.origin.y);
     rect->right         = FXSYS_ceil(r.origin.x + r.size.width);
     rect->bottom        = FXSYS_ceil(r.origin.y + r.size.height);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
+bool CFX_QuartzDeviceDriver::GetDIBits(CFX_DIBitmap*     bitmap,
         int32_t            left,
         int32_t            top,
         void* pIccTransform,
-        FX_BOOL bDEdge)
+        bool bDEdge)
 {
     if (FXDC_PRINTER == _deviceClass) {
-        return FALSE;
+        return false;
     }
     if (bitmap->GetBPP() < 32) {
-        return FALSE;
+        return false;
     }
     if (!(_renderCaps | FXRC_GET_BITS)) {
-        return FALSE;
+        return false;
     }
     CGPoint pt = CGPointMake(left, top);
     pt = CGPointApplyAffineTransform(pt, _foxitDevice2User);
     CGAffineTransform ctm = CGContextGetCTM(_context);
     pt.x *= FXSYS_fabs(ctm.a);
     pt.y *= FXSYS_fabs(ctm.d);
     CGImageRef image = CGBitmapContextCreateImage(_context);
     if (NULL == image) {
-        return FALSE;
+        return false;
     }
     CGFloat width       = (CGFloat) bitmap->GetWidth();
     CGFloat height      = (CGFloat) bitmap->GetHeight();
     if (width + pt.x > _width) {
         width -= (width + pt.x - _width);
     }
     if (height + pt.y > _height) {
         height -= (height + pt.y - _height);
     }
     CGImageRef subImage = CGImageCreateWithImageInRect(image,
@@ skipping 14 matching lines @@
             for (int col = 0; col < bitmap->GetWidth(); col ++) {
                 if (pScanline[3] > 0) {
                     pScanline[0] = (pScanline[0] * 255.f / pScanline[3] + .5f);
                     pScanline[1] = (pScanline[1] * 255.f / pScanline[3] + .5f);
                     pScanline[2] = (pScanline[2] * 255.f / pScanline[3] + .5f);
                 }
                 pScanline += 4;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
+bool CFX_QuartzDeviceDriver::SetDIBits(const CFX_DIBSource*      pBitmap,
         FX_ARGB                     argb,
         const FX_RECT*              srcRect,
         int                         dest_left,
         int                         dest_top,
         int                         blendType,
         int                         alphaFlag       ,
         void*                       iccTransform    )
 {
     SaveState();
     CGFloat src_left, src_top, src_width, src_height;
@@ skipping 23 matching lines @@
     rect_usr = CGRectOffset(rect_usr, -src_left, -src_top);
     CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
     CFX_DIBitmap* pBitmap1 = NULL;
     if (pBitmap->IsAlphaMask()) {
         if (pBitmap->GetBuffer()) {
             pBitmap1 = (CFX_DIBitmap*)pBitmap;
         } else {
             pBitmap1 = pBitmap->Clone();
         }
         if (NULL == pBitmap1) {
-            RestoreState(FALSE);
-            return FALSE;
+            RestoreState(false);
+            return false;
         }
         CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
                                             pBitmap1->GetBuffer(),
                                             pBitmap1->GetPitch() * pBitmap1->GetHeight(),
                                             NULL);
         CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
         CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
         CGImageRef pImage = CGImageCreate(pBitmap1->GetWidth(),
                                           pBitmap1->GetHeight(),
                                           pBitmap1->GetBPP(),
                                           pBitmap1->GetBPP(),
                                           pBitmap1->GetPitch(),
                                           pColorSpace,
                                           bitmapInfo,
                                           pBitmapProvider, NULL, true,
                                           kCGRenderingIntentDefault);
         CGContextClipToMask(_context, rect_usr, pImage);
         CGContextSetRGBFillColor(_context,
                                  FXARGB_R(argb) / 255.f,
                                  FXARGB_G(argb) / 255.f,
                                  FXARGB_B(argb) / 255.f,
                                  FXARGB_A(argb) / 255.f);
         CGContextFillRect(_context, rect_usr);
         CGImageRelease(pImage);
         CGColorSpaceRelease(pColorSpace);
         CGDataProviderRelease(pBitmapProvider);
         if (pBitmap1 != pBitmap) {
             delete pBitmap1;
         }
-        RestoreState(FALSE);
-        return TRUE;
+        RestoreState(false);
+        return true;
     }
     if (pBitmap->GetBPP() < 32) {
         pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
     } else {
         if (pBitmap->GetBuffer()) {
             pBitmap1 = (CFX_DIBitmap*)pBitmap;
         } else {
             pBitmap1 = pBitmap->Clone();
         }
     }
     if (NULL == pBitmap1) {
-        RestoreState(FALSE);
-        return FALSE;
+        RestoreState(false);
+        return false;
     }
     if (pBitmap1->HasAlpha()) {
         if (pBitmap1 == pBitmap) {
             pBitmap1 = pBitmap->Clone();
             if (!pBitmap1) {
-                RestoreState(FALSE);
-                return FALSE;
+                RestoreState(false);
+                return false;
             }
         }
         for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
             uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
             for (int col = 0; col < pBitmap1->GetWidth(); col ++) {
                 pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
                 pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
                 pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
                 pScanline += 4;
             }
@@ skipping 11 matching lines @@
     } else if (blendType > FXDIB_BLEND_LUMINOSITY || blendType < 0) {
         blend_mode = kCGBlendModeNormal;
     }
     CGContextSetBlendMode(_context, (CGBlendMode)blend_mode);
     CGContextDrawImage(_context, rect_usr, image);
     CGImageRelease(image);
     CGContextRelease(ctx);
     if (pBitmap1 != pBitmap) {
         delete pBitmap1;
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
+bool CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource*      pBitmap,
         FX_ARGB                     argb,
         int                         dest_left,
         int                         dest_top,
         int                         dest_width,
         int                         dest_height,
         const FX_RECT*              clipRect,
         FX_DWORD                    flags,
         int                         alphaFlag      ,
         void*                       iccTransform ,
         int                                                     blend_type)
@@ skipping 17 matching lines @@
     }
     CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height);
     CFX_DIBitmap* pBitmap1 = NULL;
     if (pBitmap->IsAlphaMask()) {
         if (pBitmap->GetBuffer()) {
             pBitmap1 = (CFX_DIBitmap*)pBitmap;
         } else {
             pBitmap1 = pBitmap->Clone();
         }
         if (NULL == pBitmap1) {
-            RestoreState(FALSE);
-            return FALSE;
+            RestoreState(false);
+            return false;
         }
         CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(NULL,
                                             pBitmap1->GetBuffer(),
                                             pBitmap1->GetPitch() * pBitmap1->GetHeight(),
                                             NULL);
         CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
         CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
         CGImageRef pImage = CGImageCreate(pBitmap1->GetWidth(),
                                           pBitmap1->GetHeight(),
                                           pBitmap1->GetBPP(),
                                           pBitmap1->GetBPP(),
                                           pBitmap1->GetPitch(),
                                           pColorSpace,
                                           bitmapInfo,
                                           pBitmapProvider, NULL, true,
                                           kCGRenderingIntentDefault);
         CGContextClipToMask(_context, rect, pImage);
         CGContextSetRGBFillColor(_context,
                                  FXARGB_R(argb) / 255.f,
                                  FXARGB_G(argb) / 255.f,
                                  FXARGB_B(argb) / 255.f,
                                  FXARGB_A(argb) / 255.f);
         CGContextFillRect(_context, rect);
         CGImageRelease(pImage);
         CGColorSpaceRelease(pColorSpace);
         CGDataProviderRelease(pBitmapProvider);
         if (pBitmap1 != pBitmap) {
             delete pBitmap1;
         }
-        RestoreState(FALSE);
-        return TRUE;
+        RestoreState(false);
+        return true;
     }
     if (pBitmap->GetBPP() < 32) {
         pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
     } else {
         if (pBitmap->GetBuffer()) {
             pBitmap1 = (CFX_DIBitmap*)pBitmap;
         } else {
             pBitmap1 = pBitmap->Clone();
         }
     }
     if (NULL == pBitmap1) {
-        RestoreState(FALSE);
-        return FALSE;
+        RestoreState(false);
+        return false;
     }
     if (pBitmap1->HasAlpha()) {
         if (pBitmap1 == pBitmap) {
             pBitmap1 = pBitmap->Clone();
             if (!pBitmap1) {
-                RestoreState(FALSE);
-                return FALSE;
+                RestoreState(false);
+                return false;
             }
         }
         for (int row = 0; row < pBitmap1->GetHeight(); row ++) {
             uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
             for (int col = 0; col < pBitmap1->GetWidth(); col ++) {
                 pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
                 pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
                 pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
                 pScanline += 4;
             }
         }
     }
     CGContextRef ctx = createContextWithBitmap(pBitmap1);
     CGImageRef image = CGBitmapContextCreateImage(ctx);
     CGContextDrawImage(_context, rect, image);
     CGImageRelease(image);
     CGContextRelease(ctx);
     if (pBitmap1 != pBitmap) {
         delete pBitmap1;
     }
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars,
+bool CFX_QuartzDeviceDriver::CG_DrawGlypRun(int                        nChars,
         const FXTEXT_CHARPOS*      pCharPos,
         CFX_Font*                  pFont,
         CFX_FontCache*             pCache,
         const CFX_AffineMatrix*    pGlyphMatrix,
         const CFX_AffineMatrix*    pObject2Device,
         FX_FLOAT                   font_size,
         FX_DWORD                   argb,
         int                        alpha_flag,
         void*                      pIccTransform)
 {
     if (nChars == 0) {
-        return TRUE;
+        return true;
     }
     CQuartz2D& quartz2d = ((CApplePlatform *) CFX_GEModule::Get()->GetPlatformData())->_quartz2d;
     if (!pFont->m_pPlatformFont) {
         if (pFont->GetPsName() == CFX_WideString::FromLocal("DFHeiStd-W5")) {
-            return FALSE;
+            return false;
         }
         pFont->m_pPlatformFont = quartz2d.CreateFont(pFont->m_pFontData, pFont->m_dwSize);
         if (NULL == pFont->m_pPlatformFont) {
-            return FALSE;
+            return false;
         }
     }
     CFX_FixedBufGrow<FX_WORD, 32> glyph_indices(nChars);
     CFX_FixedBufGrow<CGPoint, 32> glyph_positions(nChars);
     for (int i = 0; i < nChars; i++ ) {
         glyph_indices[i] = pCharPos[i].m_ExtGID;
         glyph_positions[i].x = pCharPos[i].m_OriginX;
         glyph_positions[i].y = pCharPos[i].m_OriginY;
     }
     CFX_AffineMatrix text_matrix;
@@ skipping 31 matching lines @@
         if (_foxitDevice2User.d < 0) {
             glyph_matrix = CGAffineTransformInvert(glyph_matrix);
         }
         CGContextConcatCTM(_context, glyph_matrix);
         CGContextTranslateCTM(_context, -origin.x, -origin.y);
     }
     CGContextShowGlyphsAtPositions(_context,
                                    (CGGlyph*)glyph_indices,
                                    glyph_positions,
                                    nChars);
-    RestoreState(FALSE);
-    return TRUE;
+    RestoreState(false);
+    return true;
 }
-FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
+bool CFX_QuartzDeviceDriver::DrawDeviceText(int                      nChars,
         const FXTEXT_CHARPOS*    pCharPos,
         CFX_Font*                pFont,
         CFX_FontCache*           pCache,
         const CFX_AffineMatrix*  pObject2Device,
         FX_FLOAT                 font_size,
         FX_DWORD                 color,
         int                      alpha_flag       ,
         void*                    pIccTransform)
 {
     if (NULL == pFont || NULL == _context) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL bBold = pFont->IsBold();
+    bool bBold = pFont->IsBold();
     if (!bBold && pFont->GetSubstFont() &&
             pFont->GetSubstFont()->m_Weight >= 500 &&
             pFont->GetSubstFont()->m_Weight <= 600) {
-        return FALSE;
+        return false;
     }
     SaveState();
     CGContextSetTextDrawingMode(_context, kCGTextFillClip);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     int32_t i = 0;
     while (i < nChars) {
         if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
             if (i > 0) {
                 ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device, font_size, color, alpha_flag, pIccTransform);
                 if (!ret) {
-                    RestoreState(FALSE);
+                    RestoreState(false);
                     return ret;
                 }
             }
             const FXTEXT_CHARPOS* char_pos = pCharPos + i;
             CFX_AffineMatrix glphy_matrix;
             if (font_size < 0) {
                 glphy_matrix.Concat(-1, 0, 0, -1, 0, 0);
             }
             if (char_pos->m_bGlyphAdjust) {
                 glphy_matrix.Concat(char_pos->m_AdjustMatrix[0],
                                     char_pos->m_AdjustMatrix[1],
                                     char_pos->m_AdjustMatrix[2],
                                     char_pos->m_AdjustMatrix[3], 0, 0);
             }
             ret = CG_DrawGlypRun(1, char_pos, pFont, pCache, &glphy_matrix, pObject2Device, font_size, color, alpha_flag, pIccTransform);
             if (!ret) {
-                RestoreState(FALSE);
+                RestoreState(false);
                 return ret;
             }
             i ++;
             pCharPos += i;
             nChars -= i;
             i = 0;
         } else {
             i ++;
         }
     }
     if (i > 0) {
         ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device, font_size, color, alpha_flag, pIccTransform);
     }
-    RestoreState(FALSE);
+    RestoreState(false);
     return ret;
 }
 void CFX_QuartzDeviceDriver::setStrokeInfo(const CFX_GraphStateData* graphState, FX_ARGB argb, FX_FLOAT lineWidth)
 {
     if (NULL == graphState) {
         return;
     }
     CGContextSetLineWidth(_context, lineWidth);
     CGLineCap cap;
     switch (graphState->m_LineCap) {
@@ skipping 119 matching lines @@
     for (int i = 0; i < m_saveCount; ++i) {
         CGContextRestoreGState(_context);
     }
     m_saveCount = 0;
     if (_context) {
         CGContextRelease(_context);
     }
 }
 CFX_QuartzDevice::CFX_QuartzDevice()
 {
-    m_bOwnedBitmap = FALSE;
+    m_bOwnedBitmap = false;
     m_pContext = NULL;
 }
 CFX_QuartzDevice::~CFX_QuartzDevice()
 {
     if (m_pContext) {
         CGContextRelease(m_pContext);
     }
     if (m_bOwnedBitmap) {
         delete GetBitmap();
     }
 }
 CGContextRef CFX_QuartzDevice::GetContext()
 {
     return m_pContext;
 }
-FX_BOOL CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass)
+bool CFX_QuartzDevice::Attach(CGContextRef context, int32_t nDeviceClass)
 {
     if (m_pContext) {
         CGContextRelease(m_pContext);
     }
     m_pContext = context;
     CGContextRetain(m_pContext);
     IFX_RenderDeviceDriver* pDriver = new CFX_QuartzDeviceDriver(m_pContext, nDeviceClass);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap)
+bool CFX_QuartzDevice::Attach(CFX_DIBitmap* pBitmap)
 {
     SetBitmap(pBitmap);
     m_pContext = createContextWithBitmap(pBitmap);
     if (NULL == m_pContext) {
-        return FALSE;
+        return false;
     }
     IFX_RenderDeviceDriver* pDriver = new CFX_QuartzDeviceDriver(m_pContext, FXDC_DISPLAY);
     SetDeviceDriver(pDriver);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_QuartzDevice::Create(int32_t width, int32_t height, FXDIB_Format format)
+bool CFX_QuartzDevice::Create(int32_t width, int32_t height, FXDIB_Format format)
 {
     if ((uint8_t)format < 32) {
-        return FALSE;
+        return false;
     }
     CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
     if (!pBitmap->Create(width, height, format)) {
         delete pBitmap;
-        return FALSE;
+        return false;
     }
-    m_bOwnedBitmap = TRUE;
+    m_bOwnedBitmap = true;
     return Attach(pBitmap);
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_