FX_BOOL considered harmful.

core/src/fxge/win32/fx_win32_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/fxge/fx_ge.h"
 
 #if _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_DESKTOP_
 #include <crtdbg.h>
 
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../include/fxge/fx_ge_win32.h"
 #include "../agg/include/fx_agg_driver.h"
 #include "../dib/dib_int.h"
 #include "../ge/text_int.h"
 #include "dwrite_int.h"
 #include "win32_int.h"
 
 class CWin32FontInfo final : public IFX_SystemFontInfo
 {
 public:
     CWin32FontInfo();
     ~CWin32FontInfo();
     virtual void                Release();
-    virtual     FX_BOOL         EnumFontList(CFX_FontMapper* pMapper);
-    virtual void*               MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* face, FX_BOOL& bExact);
+    virtual     bool            EnumFontList(CFX_FontMapper* pMapper);
+    virtual void*               MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* face, bool& bExact);
     virtual void*               GetFont(const FX_CHAR* face)
     {
         return NULL;
     }
     virtual FX_DWORD    GetFontData(void* hFont, FX_DWORD table, uint8_t* buffer, FX_DWORD size);
     virtual void                DeleteFont(void* hFont);
-    virtual     FX_BOOL         GetFaceName(void* hFont, CFX_ByteString& name);
-    virtual FX_BOOL             GetFontCharset(void* hFont, int& charset);
-    FX_BOOL                             IsOpenTypeFromDiv(const LOGFONTA *plf);
-    FX_BOOL                             IsSupportFontFormDiv(const LOGFONTA* plf);
+    virtual     bool            GetFaceName(void* hFont, CFX_ByteString& name);
+    virtual bool                GetFontCharset(void* hFont, int& charset);
+    bool                                IsOpenTypeFromDiv(const LOGFONTA *plf);
+    bool                                IsSupportFontFormDiv(const LOGFONTA* plf);
     void                                AddInstalledFont(const LOGFONTA *plf, FX_DWORD FontType);
     void                                GetGBPreference(CFX_ByteString& face, int weight, int picth_family);
     void                                GetJapanesePreference(CFX_ByteString& face, int weight, int picth_family);
     CFX_ByteString              FindFont(const CFX_ByteString& name);
     HDC                                 m_hDC;
     CFX_FontMapper*             m_pMapper;
     CFX_ByteString              m_LastFamily;
     CFX_ByteString              m_KaiTi, m_FangSong;
 };
 CWin32FontInfo::CWin32FontInfo()
 {
     m_hDC = CreateCompatibleDC(NULL);
 }
 CWin32FontInfo::~CWin32FontInfo()
 {
     m_pMapper = NULL;
 }
 void CWin32FontInfo::Release()
 {
     DeleteDC(m_hDC);
     delete this;
 }
 #define TT_MAKE_TAG(x1, x2, x3, x4) (((FX_DWORD)x1<<24)|((FX_DWORD)x2<<16)|((FX_DWORD)x3<<8)|(FX_DWORD)x4)
-FX_BOOL CWin32FontInfo::IsOpenTypeFromDiv(const LOGFONTA *plf)
+bool CWin32FontInfo::IsOpenTypeFromDiv(const LOGFONTA *plf)
 {
     HFONT hFont = CreateFontIndirectA(plf);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD font_size  = GetFontData(hFont, 0, NULL, 0);
     if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
         FX_DWORD lVersion = 0;
         GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(FX_DWORD));
         lVersion = (((FX_DWORD)(uint8_t)(lVersion)) << 24) | ((FX_DWORD)((uint8_t)(lVersion >> 8))) << 16 |
                    ((FX_DWORD)((uint8_t)(lVersion >> 16))) << 8 | ((uint8_t)(lVersion >> 24));
         if (lVersion == TT_MAKE_TAG('O', 'T', 'T', 'O') ||
                 lVersion == 0x00010000 ||
                 lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
                 lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') ||
                 lVersion == 0x00020000) {
-            ret = TRUE;
+            ret = true;
         }
     }
     DeleteFont(hFont);
     return ret;
 }
-FX_BOOL CWin32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf)
+bool CWin32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf)
 {
     HFONT hFont = CreateFontIndirectA(plf);
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     FX_DWORD font_size  = GetFontData(hFont, 0, NULL, 0);
     if (font_size != GDI_ERROR && font_size >= sizeof(FX_DWORD)) {
         FX_DWORD lVersion = 0;
         GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(FX_DWORD));
         lVersion = (((FX_DWORD)(uint8_t)(lVersion)) << 24) | ((FX_DWORD)((uint8_t)(lVersion >> 8))) << 16 |
                    ((FX_DWORD)((uint8_t)(lVersion >> 16))) << 8 | ((uint8_t)(lVersion >> 24));
         if (lVersion == TT_MAKE_TAG('O', 'T', 'T', 'O') ||
                 lVersion == 0x00010000 ||
                 lVersion == TT_MAKE_TAG('t', 't', 'c', 'f') ||
                 lVersion == TT_MAKE_TAG('t', 'r', 'u', 'e') ||
                 lVersion == 0x00020000) {
-            ret = TRUE;
+            ret = true;
         } else if ((lVersion & 0xFFFF0000) == TT_MAKE_TAG(0x80, 0x01, 0x00, 0x00) ||
                    (lVersion & 0xFFFF0000) == TT_MAKE_TAG('%', '!', 0, 0)) {
-            ret = TRUE;
+            ret = true;
         }
     }
     DeleteFont(hFont);
     return ret;
 }
 void CWin32FontInfo::AddInstalledFont(const LOGFONTA *plf, FX_DWORD FontType)
 {
     CFX_ByteString name(plf->lfFaceName, -1);
     if (name[0] == '@') {
         return;
@@ skipping 20 matching lines @@
     LPARAM lParam
 )
 {
     CWin32FontInfo* pFontInfo = (CWin32FontInfo*)lParam;
     if (pFontInfo->m_pMapper->GetFontEnumerator()) {
         pFontInfo->m_pMapper->GetFontEnumerator()->HitFont();
     }
     pFontInfo->AddInstalledFont(plf, FontType);
     return 1;
 }
-FX_BOOL CWin32FontInfo::EnumFontList(CFX_FontMapper* pMapper)
+bool CWin32FontInfo::EnumFontList(CFX_FontMapper* pMapper)
 {
     m_pMapper = pMapper;
     LOGFONTA lf;
     FXSYS_memset(&lf, 0, sizeof(LOGFONTA));
     lf.lfCharSet = DEFAULT_CHARSET;
     lf.lfFaceName[0] = 0;
     lf.lfPitchAndFamily = 0;
     EnumFontFamiliesExA(m_hDC, &lf, (FONTENUMPROCA)FontEnumProc, (uintptr_t)this, 0);
     if (pMapper->GetFontEnumerator()) {
         pMapper->GetFontEnumerator()->Finish();
     }
-    return TRUE;
+    return true;
 }
 static const struct {
     const FX_CHAR*      m_pFaceName;
     const FX_CHAR*      m_pVariantName;
 }
 VariantNames[] = {
     {"DFKai-SB", "\x19\x6A\x77\x69\xD4\x9A"},
 };
 static const struct {
     const FX_CHAR*      m_pName;
     const FX_CHAR*      m_pWinName;
-    FX_BOOL             m_bBold;
-    FX_BOOL             m_bItalic;
+    bool                m_bBold;
+    bool                m_bItalic;
 }
 Base14Substs[] = {
-    {"Courier", "Courier New", FALSE, FALSE},
-    {"Courier-Bold", "Courier New", TRUE, FALSE},
-    {"Courier-BoldOblique", "Courier New", TRUE, TRUE},
-    {"Courier-Oblique", "Courier New", FALSE, TRUE},
-    {"Helvetica", "Arial", FALSE, FALSE},
-    {"Helvetica-Bold", "Arial", TRUE, FALSE},
-    {"Helvetica-BoldOblique", "Arial", TRUE, TRUE},
-    {"Helvetica-Oblique", "Arial", FALSE, TRUE},
-    {"Times-Roman", "Times New Roman", FALSE, FALSE},
-    {"Times-Bold", "Times New Roman", TRUE, FALSE},
-    {"Times-BoldItalic", "Times New Roman", TRUE, TRUE},
-    {"Times-Italic", "Times New Roman", FALSE, TRUE},
+    {"Courier", "Courier New", false, false},
+    {"Courier-Bold", "Courier New", true, false},
+    {"Courier-BoldOblique", "Courier New", true, true},
+    {"Courier-Oblique", "Courier New", false, true},
+    {"Helvetica", "Arial", false, false},
+    {"Helvetica-Bold", "Arial", true, false},
+    {"Helvetica-BoldOblique", "Arial", true, true},
+    {"Helvetica-Oblique", "Arial", false, true},
+    {"Times-Roman", "Times New Roman", false, false},
+    {"Times-Bold", "Times New Roman", true, false},
+    {"Times-BoldItalic", "Times New Roman", true, true},
+    {"Times-Italic", "Times New Roman", false, true},
 };
 CFX_ByteString CWin32FontInfo::FindFont(const CFX_ByteString& name)
 {
     if (m_pMapper == NULL) {
         return name;
     }
     int nFonts = m_pMapper->m_InstalledTTFonts.GetSize();
     for (int i = 0; i < nFonts; i ++) {
         CFX_ByteString thisname = m_pMapper->m_InstalledTTFonts[i];
         if (thisname[0] == ' ') {
@@ skipping 13 matching lines @@
 const _FontNameMap g_JpFontNameMap[] = {
     {"MS Mincho", "Heiseimin-W3"},
     {"MS Gothic", "Jun101-Light"},
 };
 extern "C" {
     static int compareString(const void* key, const void* element)
     {
         return FXSYS_stricmp((const FX_CHAR*)key, ((_FontNameMap*)element)->m_pSrcFontName);
     }
 }
-FX_BOOL _GetSubFontName(CFX_ByteString& name)
+bool _GetSubFontName(CFX_ByteString& name)
 {
     int size = sizeof g_JpFontNameMap;
     void* pFontnameMap = (void*)g_JpFontNameMap;
     _FontNameMap* found = (_FontNameMap*)FXSYS_bsearch(name.c_str(), pFontnameMap,
                           size / sizeof (_FontNameMap), sizeof (_FontNameMap), compareString);
     if (found == NULL) {
-        return FALSE;
+        return false;
     }
     name = found->m_pSubFontName;
-    return TRUE;
+    return true;
 }
 void CWin32FontInfo::GetGBPreference(CFX_ByteString& face, int weight, int picth_family)
 {
     if (face.Find("KaiTi") >= 0 || face.Find("\xbf\xac") >= 0) {
         if (m_KaiTi.IsEmpty()) {
             m_KaiTi = FindFont("KaiTi");
             if (m_KaiTi.IsEmpty()) {
                 m_KaiTi = "SimSun";
             }
         }
@@ skipping 41 matching lines @@
     }
     if (_GetSubFontName(face)) {
         return;
     }
     if (!(picth_family & FF_ROMAN) && weight > 400) {
         face = "MS PGothic";
     } else {
         face = "MS PMincho";
     }
 }
-void* CWin32FontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, FX_BOOL& bExact)
+void* CWin32FontInfo::MapFont(int weight, bool bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, bool& bExact)
 {
     CFX_ByteString face = cstr_face;
     int iBaseFont;
     for (iBaseFont = 0; iBaseFont < 12; iBaseFont ++)
         if (face == CFX_ByteStringC(Base14Substs[iBaseFont].m_pName)) {
             face = Base14Substs[iBaseFont].m_pWinName;
             weight = Base14Substs[iBaseFont].m_bBold ? FW_BOLD : FW_NORMAL;
             bItalic = Base14Substs[iBaseFont].m_bItalic;
-            bExact = TRUE;
+            bExact = true;
             break;
         }
     if (charset == ANSI_CHARSET || charset == SYMBOL_CHARSET) {
         charset = DEFAULT_CHARSET;
     }
     int subst_pitch_family = pitch_family;
     switch (charset) {
         case SHIFTJIS_CHARSET:
             subst_pitch_family = FF_ROMAN;
             break;
@@ skipping 58 matching lines @@
 {
     HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
     table = FXDWORD_FROM_MSBFIRST(table);
     size = ::GetFontData(m_hDC, table, 0, buffer, size);
     ::SelectObject(m_hDC, hOldFont);
     if (size == GDI_ERROR) {
         return 0;
     }
     return size;
 }
-FX_BOOL CWin32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
+bool CWin32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name)
 {
     char facebuf[100];
     HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
     int ret = ::GetTextFaceA(m_hDC, 100, facebuf);
     ::SelectObject(m_hDC, hOldFont);
     if (ret == 0) {
-        return FALSE;
+        return false;
     }
     name = facebuf;
-    return TRUE;
+    return true;
 }
-FX_BOOL CWin32FontInfo::GetFontCharset(void* hFont, int& charset)
+bool CWin32FontInfo::GetFontCharset(void* hFont, int& charset)
 {
     TEXTMETRIC tm;
     HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
     ::GetTextMetrics(m_hDC, &tm);
     ::SelectObject(m_hDC, hOldFont);
     charset = tm.tmCharSet;
-    return TRUE;
+    return true;
 }
 IFX_SystemFontInfo* IFX_SystemFontInfo::CreateDefault()
 {
     return new CWin32FontInfo;
 }
 void CFX_GEModule::InitPlatform()
 {
     CWin32Platform* pPlatformData = new CWin32Platform;
     OSVERSIONINFO ver;
     ver.dwOSVersionInfoSize = sizeof(ver);
@@ skipping 53 matching lines @@
 }
 void* CGdiDeviceDriver::GetClipRgn()
 {
     HRGN hClipRgn = CreateRectRgn(0, 0, 1, 1);
     if (::GetClipRgn(m_hDC, hClipRgn) == 0) {
         DeleteObject(hClipRgn);
         hClipRgn = NULL;
     }
     return (void*)hClipRgn;
 }
-FX_BOOL CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_RECT* pSrcRect, int left, int top, void* pIccTransform)
+bool CGdiDeviceDriver::GDI_SetDIBits(const CFX_DIBitmap* pBitmap1, const FX_RECT* pSrcRect, int left, int top, void* pIccTransform)
 {
     if (m_DeviceClass == FXDC_PRINTER) {
-        CFX_DIBitmap* pBitmap = pBitmap1->FlipImage(FALSE, TRUE);
+        CFX_DIBitmap* pBitmap = pBitmap1->FlipImage(false, true);
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         if ((pBitmap->IsCmykImage() || pIccTransform) &&
                 !pBitmap->ConvertFormat(FXDIB_Rgb, pIccTransform)) {
-            return FALSE;
+            return false;
         }
         int width = pSrcRect->Width(), height = pSrcRect->Height();
         int pitch = pBitmap->GetPitch();
         LPBYTE pBuffer = pBitmap->GetBuffer();
         CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
         ((BITMAPINFOHEADER*)info.c_str())->biHeight *= -1;
         FX_RECT dst_rect(0, 0, width, height);
         dst_rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
         int dst_width = dst_rect.Width();
         int dst_height = dst_rect.Height();
         ::StretchDIBits(m_hDC, left, top, dst_width, dst_height,
             0, 0, dst_width, dst_height, pBuffer, (BITMAPINFO*)info.c_str(), DIB_RGB_COLORS, SRCCOPY);
         delete pBitmap;
     } else {
         CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
         if ((pBitmap->IsCmykImage() || pIccTransform) &&
                 (pBitmap = pBitmap->CloneConvert(FXDIB_Rgb, NULL, pIccTransform)) == NULL) {
-            return FALSE;
+            return false;
         }
         int width = pSrcRect->Width(), height = pSrcRect->Height();
         int pitch = pBitmap->GetPitch();
         LPBYTE pBuffer = pBitmap->GetBuffer();
         CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
         ::SetDIBitsToDevice(m_hDC, left, top, width, height, pSrcRect->left, pBitmap->GetHeight() - pSrcRect->bottom,
             0, pBitmap->GetHeight(), pBuffer, (BITMAPINFO*)info.c_str(), DIB_RGB_COLORS);
         if (pBitmap != pBitmap1) {
             delete pBitmap;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
+bool CGdiDeviceDriver::GDI_StretchDIBits(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
         int dest_width, int dest_height, FX_DWORD flags, void* pIccTransform)
 {
     CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
     if (pBitmap == NULL || dest_width == 0  || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     if ((pBitmap->IsCmykImage() || pIccTransform) &&
             !pBitmap->ConvertFormat(FXDIB_Rgb, pIccTransform)) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
     if ((int64_t)abs(dest_width) * abs(dest_height) < (int64_t)pBitmap1->GetWidth() * pBitmap1->GetHeight() * 4 ||
             (flags & FXDIB_INTERPOL) || (flags & FXDIB_BICUBIC_INTERPOL)) {
         SetStretchBltMode(m_hDC, HALFTONE);
     } else {
         SetStretchBltMode(m_hDC, COLORONCOLOR);
     }
     CFX_DIBitmap* pToStrechBitmap = pBitmap;
     bool del = false;
     if (m_DeviceClass == FXDC_PRINTER && ((int64_t)pBitmap->GetWidth() * pBitmap->GetHeight() > (int64_t)abs(dest_width) * abs(dest_height))) {
         pToStrechBitmap = pBitmap->StretchTo(dest_width, dest_height);
         del = true;
     }
     CFX_ByteString toStrechBitmapInfo = CFX_WindowsDIB::GetBitmapInfo(pToStrechBitmap);
     ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height,
                     0, 0, pToStrechBitmap->GetWidth(), pToStrechBitmap->GetHeight(), pToStrechBitmap->GetBuffer(),
                     (BITMAPINFO*)toStrechBitmapInfo.c_str(), DIB_RGB_COLORS, SRCCOPY);
     if (del) {
         delete pToStrechBitmap;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
+bool CGdiDeviceDriver::GDI_StretchBitMask(const CFX_DIBitmap* pBitmap1, int dest_left, int dest_top,
         int dest_width, int dest_height, FX_DWORD bitmap_color, FX_DWORD flags,
         int alpha_flag, void* pIccTransform)
 {
     CFX_DIBitmap* pBitmap = (CFX_DIBitmap*)pBitmap1;
     if (pBitmap == NULL || dest_width == 0  || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(bitmap_color, bitmap_color, alpha_flag | (1 << 24), pIccTransform);
     int width = pBitmap->GetWidth(), height = pBitmap->GetHeight();
     struct {
         BITMAPINFOHEADER        bmiHeader;
         FX_DWORD                        bmiColors[2];
     } bmi;
     FXSYS_memset(&bmi.bmiHeader, 0, sizeof (BITMAPINFOHEADER));
     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
     bmi.bmiHeader.biBitCount = 1;
@@ skipping 25 matching lines @@
      *        1                 1                1              1
      */
     // The boolen codes is B8. Based on http://msdn.microsoft.com/en-us/library/aa932106.aspx, the ROP3 code is 0xB8074A
 
     ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height,
                     0, 0, width, height, pBitmap->GetBuffer(), (BITMAPINFO*)&bmi, DIB_RGB_COLORS, 0xB8074A);
 
     SelectObject(m_hDC, hOld);
     DeleteObject(hPattern);
 
-    return TRUE;
+    return true;
 }
 BOOL CGdiDeviceDriver::GetClipBox(FX_RECT* pRect)
 {
     return ::GetClipBox(m_hDC, (RECT*)pRect);
 }
-FX_BOOL CGdiDeviceDriver::SetClipRgn(void* hRgn)
+bool CGdiDeviceDriver::SetClipRgn(void* hRgn)
 {
     ::SelectClipRgn(m_hDC, (HRGN)hRgn);
-    return TRUE;
+    return true;
 }
 static HPEN _CreatePen(const CFX_GraphStateData* pGraphState, const CFX_AffineMatrix* pMatrix, FX_DWORD argb)
 {
     FX_FLOAT width;
     FX_FLOAT scale = 1.f;
     if (pMatrix)
         scale = FXSYS_fabs(pMatrix->a) > FXSYS_fabs(pMatrix->b) ?
                 FXSYS_fabs(pMatrix->a) : FXSYS_fabs(pMatrix->b);
     if (pGraphState) {
         width = scale * pGraphState->m_LineWidth;
@@ skipping 127 matching lines @@
         } else {
             x1 = x[0];
             y1 = y[0];
             x2 = x[np - 1];
             y2 = y[np - 1];
         }
     }
     MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), NULL);
     LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
 }
-static FX_BOOL _MatrixNoScaled(const CFX_AffineMatrix* pMatrix)
+static bool _MatrixNoScaled(const CFX_AffineMatrix* pMatrix)
 {
     return pMatrix->GetA() == 1.0f && pMatrix->GetB() == 0 && pMatrix->GetC() == 0 && pMatrix->GetD() == 1.0f;
 }
-FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                    const CFX_AffineMatrix* pMatrix,
                                    const CFX_GraphStateData* pGraphState,
                                    FX_DWORD fill_color,
                                    FX_DWORD stroke_color,
                                    int fill_mode,
                                    int alpha_flag,
                                    void* pIccTransform,
                                    int  blend_type
                                   )
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
     _Color2Argb(stroke_color, stroke_color, alpha_flag, pIccTransform);
     CWin32Platform* pPlatform = (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
     if ((pGraphState == NULL || stroke_color == 0) && !pPlatform->m_GdiplusExt.IsAvailable()) {
         CFX_FloatRect bbox_f = pPathData->GetBoundingBox();
         if (pMatrix) {
             bbox_f.Transform(pMatrix);
         }
         FX_RECT bbox = bbox_f.GetInnerRect();
         if (bbox.Width() <= 0) {
             return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top), (FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.bottom + 1), fill_color,
                                     alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);
         } else if (bbox.Height() <= 0) {
             return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top), (FX_FLOAT)(bbox.right + 1), (FX_FLOAT)(bbox.top), fill_color,
                                     alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);
         }
     }
     int fill_alpha = FXARGB_A(fill_color);
     int stroke_alpha = FXARGB_A(stroke_color);
-    FX_BOOL bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) || (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
+    bool bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) || (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
     if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha) {
-        return FALSE;
+        return false;
     }
     if (pPlatform->m_GdiplusExt.IsAvailable()) {
         if (bDrawAlpha || ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) || (pGraphState && pGraphState->m_DashCount))) {
             if ( !((NULL == pMatrix || _MatrixNoScaled(pMatrix)) &&
                     pGraphState && pGraphState->m_LineWidth == 1.f &&
                     (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) &&
                     pPathData->IsRect()) ) {
                 if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix, pGraphState, fill_color, stroke_color, fill_mode)) {
-                    return TRUE;
+                    return true;
                 }
             }
         }
     }
     int old_fill_mode = fill_mode;
     fill_mode &= 3;
     HPEN hPen = NULL;
     HBRUSH hBrush = NULL;
     if (pGraphState && stroke_alpha) {
         SetMiterLimit(m_hDC, pGraphState->m_MiterLimit, NULL);
@@ skipping 34 matching lines @@
         }
     }
     if (hPen) {
         hPen = (HPEN)SelectObject(m_hDC, hPen);
         DeleteObject(hPen);
     }
     if (hBrush) {
         hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
         DeleteObject(hBrush);
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
+bool CGdiDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform, int blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(fill_color, fill_color, alpha_flag | (1 << 24), pIccTransform);
     int alpha;
     FX_COLORREF rgb;
     ArgbDecode(fill_color, alpha, rgb);
     if (alpha == 0) {
-        return TRUE;
+        return true;
     }
     if (alpha < 255) {
-        return FALSE;
+        return false;
     }
     HBRUSH hBrush = CreateSolidBrush(rgb);
     ::FillRect(m_hDC, (RECT*)pRect, hBrush);
     DeleteObject(hBrush);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pMatrix,
         int fill_mode
                                           )
 {
     if (pPathData->GetPointCount() == 5) {
         CFX_FloatRect rectf;
         if (pPathData->IsRect(pMatrix, &rectf)) {
             FX_RECT rect = rectf.GetOutterRect();
             IntersectClipRect(m_hDC, rect.left, rect.top, rect.right, rect.bottom);
-            return TRUE;
+            return true;
         }
     }
     _SetPathToDC(m_hDC, pPathData, pMatrix);
     SetPolyFillMode(m_hDC, fill_mode & 3);
     SelectClipPath(m_hDC, RGN_AND);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
+bool CGdiDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
         const CFX_AffineMatrix* pMatrix,
         const CFX_GraphStateData* pGraphState
                                             )
 {
     HPEN hPen = _CreatePen(pGraphState, pMatrix, 0xff000000);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     _SetPathToDC(m_hDC, pPathData, pMatrix);
     WidenPath(m_hDC);
     SetPolyFillMode(m_hDC, WINDING);
-    FX_BOOL ret = SelectClipPath(m_hDC, RGN_AND);
+    bool ret = SelectClipPath(m_hDC, RGN_AND);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
     return ret;
 }
-FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
+bool CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1, FX_FLOAT y1, FX_FLOAT x2, FX_FLOAT y2, FX_DWORD color,
         int alpha_flag, void* pIccTransform, int        blend_type)
 {
     if (blend_type != FXDIB_BLEND_NORMAL) {
-        return FALSE;
+        return false;
     }
     _Color2Argb(color, color, alpha_flag | (1 << 24), pIccTransform);
     int a;
     FX_COLORREF rgb;
     ArgbDecode(color, a, rgb);
     if (a == 0) {
-        return TRUE;
+        return true;
     }
     HPEN hPen = CreatePen(PS_SOLID, 1, rgb);
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), NULL);
     LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
-    return TRUE;
+    return true;
 }
-FX_BOOL CGdiDeviceDriver::DeleteDeviceRgn(void* pRgn)
+bool CGdiDeviceDriver::DeleteDeviceRgn(void* pRgn)
 {
     DeleteObject((HGDIOBJ)pRgn);
-    return TRUE;
+    return true;
 }
 CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC) : CGdiDeviceDriver(hDC, FXDC_DISPLAY)
 {
     CWin32Platform* pPlatform = (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
     if (pPlatform->m_GdiplusExt.IsAvailable()) {
         m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE;
     }
 }
-FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
+bool CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, bool bDEdge)
 {
-    FX_BOOL ret = FALSE;
+    bool ret = false;
     int width = pBitmap->GetWidth();
     int height = pBitmap->GetHeight();
     HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height);
     HDC hDCMemory = CreateCompatibleDC(m_hDC);
     HBITMAP holdbmp  = (HBITMAP)SelectObject(hDCMemory, hbmp);
     BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY);
     SelectObject(hDCMemory, holdbmp);
     BITMAPINFO bmi;
     FXSYS_memset(&bmi, 0, sizeof bmi);
     bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
     bmi.bmiHeader.biBitCount = pBitmap->GetBPP();
     bmi.bmiHeader.biHeight = -height;
     bmi.bmiHeader.biPlanes = 1;
     bmi.bmiHeader.biWidth = width;
     if (!CFX_GEModule::Get()->GetCodecModule() || !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         pIccTransform = NULL;
     }
     if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage() && pIccTransform == NULL) {
         ret = ::GetDIBits(hDCMemory, hbmp, 0, height, pBitmap->GetBuffer(), &bmi, DIB_RGB_COLORS) == height;
     } else {
         CFX_DIBitmap bitmap;
         if (bitmap.Create(width, height, FXDIB_Rgb)) {
             bmi.bmiHeader.biBitCount = 24;
             ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap.GetBuffer(), &bmi, DIB_RGB_COLORS);
             ret = pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0, pIccTransform);
         } else {
-            ret = FALSE;
+            ret = false;
         }
     }
     if (pBitmap->HasAlpha() && ret) {
         pBitmap->LoadChannel(FXDIB_Alpha, 0xff);
     }
     DeleteObject(hbmp);
     DeleteObject(hDCMemory);
     return ret;
 }
-FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource, FX_DWORD color, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                      int alpha_flag, void* pIccTransform)
 {
     ASSERT(blend_type == FXDIB_BLEND_NORMAL);
     if (pSource->IsAlphaMask()) {
         int width = pSource->GetWidth(), height = pSource->GetHeight();
         int alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
-        FX_BOOL bGDI = pSource->GetBPP() == 1 && alpha == 255;
+        bool bGDI = pSource->GetBPP() == 1 && alpha == 255;
         if (!bGDI) {
             CFX_DIBitmap background;
             if (!background.Create(width, height, FXDIB_Rgb32) ||
                     !GetDIBits(&background, left, top, NULL) ||
-                    !background.CompositeMask(0, 0, width, height, pSource, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, FALSE, alpha_flag, pIccTransform)) {
-                return FALSE;
+                    !background.CompositeMask(0, 0, width, height, pSource, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, false, alpha_flag, pIccTransform)) {
+                return false;
             }
             FX_RECT src_rect(0, 0, width, height);
             return SetDIBits(&background, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL, 0, NULL);
         }
         FX_RECT clip_rect(left, top, left + pSrcRect->Width(), top + pSrcRect->Height());
         return StretchDIBits(pSource, color, left - pSrcRect->left, top - pSrcRect->top, width, height,
                              &clip_rect, 0, alpha_flag, pIccTransform, FXDIB_BLEND_NORMAL);
     } else {
         int width = pSrcRect->Width(), height = pSrcRect->Height();
         if (pSource->HasAlpha()) {
             CFX_DIBitmap bitmap;
             if (!bitmap.Create(width, height, FXDIB_Rgb) ||
                     !GetDIBits(&bitmap, left, top, NULL) ||
-                    !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left, pSrcRect->top, FXDIB_BLEND_NORMAL, NULL, FALSE, pIccTransform)) {
-                return FALSE;
+                    !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left, pSrcRect->top, FXDIB_BLEND_NORMAL, NULL, false, pIccTransform)) {
+                return false;
             }
             FX_RECT src_rect(0, 0, width, height);
             return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL, 0, NULL);
         }
         CFX_DIBExtractor temp(pSource);
         CFX_DIBitmap* pBitmap = temp;
         if (pBitmap) {
             return GDI_SetDIBits(pBitmap, pSrcRect, left, top, pIccTransform);
         }
     }
-    return FALSE;
+    return false;
 }
-FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, int render_flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
     FX_RECT bitmap_clip = *pClipRect;
     if (dest_width < 0) {
         dest_left += dest_width;
     }
     if (dest_height < 0) {
         dest_top += dest_height;
     }
     bitmap_clip.Offset(-dest_left, -dest_top);
     CFX_DIBitmap* pStretched = pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip);
     if (pStretched == NULL) {
-        return TRUE;
+        return true;
     }
     FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
-    FX_BOOL ret = SetDIBits(pStretched, color, &src_rect, pClipRect->left, pClipRect->top, FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
+    bool ret = SetDIBits(pStretched, color, &src_rect, pClipRect->left, pClipRect->top, FXDIB_BLEND_NORMAL, alpha_flag, pIccTransform);
     delete pStretched;
     return ret;
 }
-FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
+bool CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD color, int dest_left, int dest_top,
         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
         int alpha_flag, void* pIccTransform, int blend_type)
 {
     ASSERT(pSource != NULL && pClipRect != NULL);
     if (flags || dest_width > 10000 || dest_width < -10000 || dest_height > 10000 || dest_height < -10000)
         return UseFoxitStretchEngine(pSource, color, dest_left, dest_top, dest_width, dest_height,
                                      pClipRect, flags, alpha_flag, pIccTransform, blend_type);
     if (pSource->IsAlphaMask()) {
         FX_RECT image_rect;
         image_rect.left = dest_width > 0 ? dest_left : dest_left + dest_width;
         image_rect.right = dest_width > 0 ? dest_left + dest_width : dest_left;
         image_rect.top = dest_height > 0 ? dest_top : dest_top + dest_height;
         image_rect.bottom = dest_height > 0 ? dest_top + dest_height : dest_top;
         FX_RECT clip_rect = image_rect;
         clip_rect.Intersect(*pClipRect);
         clip_rect.Offset(-image_rect.left, -image_rect.top);
         int clip_width = clip_rect.Width(), clip_height = clip_rect.Height();
         CFX_DIBitmap* pStretched = pSource->StretchTo(dest_width, dest_height, flags, &clip_rect);
         if (pStretched == NULL) {
-            return TRUE;
+            return true;
         }
         CFX_DIBitmap background;
         if (!background.Create(clip_width, clip_height, FXDIB_Rgb32) ||
                 !GetDIBits(&background, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, NULL) ||
-                !background.CompositeMask(0, 0, clip_width, clip_height, pStretched, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, FALSE, alpha_flag, pIccTransform)) {
+                !background.CompositeMask(0, 0, clip_width, clip_height, pStretched, color, 0, 0, FXDIB_BLEND_NORMAL, NULL, false, alpha_flag, pIccTransform)) {
             delete pStretched;
-            return FALSE;
+            return false;
         }
         FX_RECT src_rect(0, 0, clip_width, clip_height);
-        FX_BOOL ret = SetDIBits(&background, 0, &src_rect, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL, 0, NULL);
+        bool ret = SetDIBits(&background, 0, &src_rect, image_rect.left + clip_rect.left, image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL, 0, NULL);
         delete pStretched;
         return ret;
     } else {
         if (pSource->HasAlpha()) {
             CWin32Platform* pPlatform = (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
             if (pPlatform->m_GdiplusExt.IsAvailable() && pIccTransform == NULL && !pSource->IsCmykImage()) {
                 CFX_DIBExtractor temp(pSource);
                 CFX_DIBitmap* pBitmap = temp;
                 if (pBitmap == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 return pPlatform->m_GdiplusExt.StretchDIBits(m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height, pClipRect, flags);
             }
             return UseFoxitStretchEngine(pSource, color, dest_left, dest_top, dest_width, dest_height,
                                          pClipRect, flags, alpha_flag, pIccTransform, blend_type);
         }
         CFX_DIBExtractor temp(pSource);
         CFX_DIBitmap* pBitmap = temp;
         if (pBitmap) {
             return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width, dest_height, flags, pIccTransform);
         }
     }
-    return FALSE;
+    return false;
 }
 #define GET_PS_FEATURESETTING        4121
 #define FEATURESETTING_PSLEVEL       2
 int GetPSLevel(HDC hDC)
 {
     int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
     if (device_type != DT_RASPRINTER) {
         return 0;
     }
     FX_DWORD esc = GET_PS_FEATURESETTING;
@@ skipping 18 matching lines @@
     esc = GET_PS_FEATURESETTING;
     if (ExtEscape(hDC, QUERYESCSUPPORT, sizeof esc, (char*)&esc, 0, NULL)) {
         int param = FEATURESETTING_PSLEVEL;
         if (ExtEscape(hDC, GET_PS_FEATURESETTING, sizeof(int), (char*)&param, sizeof(int), (char*)&param) > 0) {
             return param;
         }
     }
     return 2;
 }
 int CFX_WindowsDevice::m_psLevel = 2;
-CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC, FX_BOOL bCmykOutput, FX_BOOL bForcePSOutput, int psLevel)
+CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC, bool bCmykOutput, bool bForcePSOutput, int psLevel)
 {
     m_bForcePSOutput = bForcePSOutput;
     m_psLevel = psLevel;
     if (bForcePSOutput) {
         IFX_RenderDeviceDriver* pDriver = new CPSPrinterDriver;
         ((CPSPrinterDriver*)pDriver)->Init(hDC, psLevel, bCmykOutput);
         SetDeviceDriver(pDriver);
         return;
     }
     SetDeviceDriver(CreateDriver(hDC, bCmykOutput));
 }
 HDC CFX_WindowsDevice::GetDC() const
 {
     IFX_RenderDeviceDriver *pRDD = GetDeviceDriver();
     if (!pRDD) {
         return NULL;
     }
     return (HDC)pRDD->GetPlatformSurface();
 }
-IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC, FX_BOOL bCmykOutput)
+IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC, bool bCmykOutput)
 {
     int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
     int obj_type = ::GetObjectType(hDC);
     int device_class;
     if (device_type == DT_RASPRINTER || device_type == DT_PLOTTER || obj_type == OBJ_ENHMETADC) {
         device_class = FXDC_PRINTER;
     } else {
         device_class = FXDC_DISPLAY;
     }
     if (device_class == FXDC_PRINTER) {
@@ skipping 29 matching lines @@
         SelectObject(m_hDC, m_hOldBitmap);
         DeleteDC(m_hDC);
     }
     if (m_hBitmap) {
         DeleteObject(m_hBitmap);
     }
     delete GetBitmap();
 }
 
 #endif  // _FX_OS_ == _FX_WIN32_DESKTOP_ || _FX_OS_ == _FX_WIN64_