FX_BOOL considered harmful.

core/src/fxge/dib/fx_dib_main.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_dib.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "dib_int.h"
 #include <limits.h>
-FX_BOOL ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
+bool ConvertBuffer(FXDIB_Format dest_format, uint8_t* dest_buf, int dest_pitch, int width, int height,
                       const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, FX_DWORD*& pal, void* pIccTransform);
 void CmykDecode(FX_DWORD cmyk, int& c, int& m, int& y, int& k)
 {
     c = FXSYS_GetCValue(cmyk);
     m = FXSYS_GetMValue(cmyk);
     y = FXSYS_GetYValue(cmyk);
     k = FXSYS_GetKValue(cmyk);
 }
 void ArgbDecode(FX_DWORD argb, int& a, int& r, int& g, int& b)
 {
@@ skipping 22 matching lines @@
 }
 CFX_DIBSource::~CFX_DIBSource()
 {
     if (m_pPalette) {
         FX_Free(m_pPalette);
     }
     delete m_pAlphaMask;
 }
 CFX_DIBitmap::CFX_DIBitmap()
 {
-    m_bExtBuf = FALSE;
+    m_bExtBuf = false;
     m_pBuffer = NULL;
     m_pPalette = NULL;
 }
 #define _MAX_OOM_LIMIT_ 12000000
-FX_BOOL CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer, int pitch)
+bool CFX_DIBitmap::Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer, int pitch)
 {
     m_pBuffer = NULL;
     m_bpp = (uint8_t)format;
     m_AlphaFlag = (uint8_t)(format >> 8);
     m_Width = m_Height = m_Pitch = 0;
     if (width <= 0 || height <= 0 || pitch < 0) {
-        return FALSE;
+        return false;
     }
     if ((INT_MAX - 31) / width < (format & 0xff)) {
-        return FALSE;
+        return false;
     }
     if (!pitch) {
         pitch = (width * (format & 0xff) + 31) / 32 * 4;
     }
     if ((1 << 30) / pitch < height) {
-        return FALSE;
+        return false;
     }
     if (pBuffer) {
         m_pBuffer = pBuffer;
-        m_bExtBuf = TRUE;
+        m_bExtBuf = true;
     } else {
         int size = pitch * height + 4;
         int oomlimit = _MAX_OOM_LIMIT_;
         if (oomlimit >= 0 && size >= oomlimit) {
             m_pBuffer = FX_TryAlloc(uint8_t, size);
             if (m_pBuffer == NULL) {
-                return FALSE;
+                return false;
             }
         } else {
             m_pBuffer = FX_Alloc(uint8_t, size);
         }
     }
     m_Width = width;
     m_Height = height;
     m_Pitch = pitch;
     if (HasAlpha() && format != FXDIB_Argb) {
-        FX_BOOL ret = TRUE;
+        bool ret = true;
         ret = BuildAlphaMask();
         if (!ret) {
             if (!m_bExtBuf && m_pBuffer) {
                 FX_Free(m_pBuffer);
                 m_pBuffer = NULL;
                 m_Width = m_Height = m_Pitch = 0;
-                return FALSE;
+                return false;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
+bool CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc)
 {
     if (m_pBuffer) {
-        return FALSE;
+        return false;
     }
     if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
-        return FALSE;
+        return false;
     }
     CopyPalette(pSrc->GetPalette());
     CopyAlphaMask(pSrc->m_pAlphaMask);
     for (int row = 0; row < pSrc->GetHeight(); row ++) {
         FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
     }
-    return TRUE;
+    return true;
 }
 CFX_DIBitmap::~CFX_DIBitmap()
 {
     if (m_pBuffer && !m_bExtBuf) {
         FX_Free(m_pBuffer);
     }
     m_pBuffer = NULL;
 }
 void CFX_DIBitmap::TakeOver(CFX_DIBitmap* pSrcBitmap)
 {
@@ skipping 77 matching lines @@
             for (int i = 0; i < 256; i ++) {
                 m_pPalette[i] = 0xff - i;
             }
         } else {
             for (int i = 0; i < 256; i ++) {
                 m_pPalette[i] = 0xff000000 | (i * 0x10101);
             }
         }
     }
 }
-FX_BOOL CFX_DIBSource::BuildAlphaMask()
+bool CFX_DIBSource::BuildAlphaMask()
 {
     if (m_pAlphaMask) {
-        return TRUE;
+        return true;
     }
     m_pAlphaMask = new CFX_DIBitmap;
     if (!m_pAlphaMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
         delete m_pAlphaMask;
         m_pAlphaMask = NULL;
-        return FALSE;
+        return false;
     }
     FXSYS_memset(m_pAlphaMask->GetBuffer(), 0xff, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-    return TRUE;
+    return true;
 }
 FX_DWORD CFX_DIBSource::GetPaletteEntry(int index) const
 {
     ASSERT((GetBPP() == 1 || GetBPP() == 8) && !IsAlphaMask());
     if (m_pPalette) {
         return m_pPalette[index];
     }
     if (IsCmykImage()) {
         if (GetBPP() == 1) {
             return index ? 0 : 0xff;
@@ skipping 116 matching lines @@
     if (pClipRgn) {
         dest_rect.Intersect(pClipRgn->GetBox());
     }
     dest_left = dest_rect.left;
     dest_top = dest_rect.top;
     src_left = dest_left - x_offset;
     src_top = dest_top - y_offset;
     width = dest_rect.right - dest_rect.left;
     height = dest_rect.bottom - dest_rect.top;
 }
-FX_BOOL CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::TransferBitmap(int dest_left, int dest_top, int width, int height,
                                      const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pSrcBitmap->GetWidth(), pSrcBitmap->GetHeight(), src_left, src_top, NULL);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     FXDIB_Format dest_format = GetFormat();
     FXDIB_Format src_format = pSrcBitmap->GetFormat();
     if (dest_format == src_format && pIccTransform == NULL) {
         if (GetBPP() == 1) {
             for (int row = 0; row < height; row ++) {
                 uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch;
                 const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
                 for (int col = 0; col < width; col ++) {
                     if (src_scan[(src_left + col) / 8] & (1 << (7 - (src_left + col) % 8))) {
                         dest_scan[(dest_left + col) / 8] |= 1 << (7 - (dest_left + col) % 8);
                     } else {
                         dest_scan[(dest_left + col) / 8] &= ~(1 << (7 - (dest_left + col) % 8));
                     }
                 }
             }
         } else {
             int Bpp = GetBPP() / 8;
             for (int row = 0; row < height; row ++) {
                 uint8_t* dest_scan = m_pBuffer + (dest_top + row) * m_Pitch + dest_left * Bpp;
                 const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left * Bpp;
                 FXSYS_memcpy(dest_scan, src_scan, width * Bpp);
             }
         }
     } else {
         if (m_pPalette) {
-            return FALSE;
+            return false;
         }
         if (m_bpp == 8) {
             dest_format = FXDIB_8bppMask;
         }
         uint8_t* dest_buf = m_pBuffer + dest_top * m_Pitch + dest_left * GetBPP() / 8;
         FX_DWORD* d_plt = NULL;
         if(!ConvertBuffer(dest_format, dest_buf, m_Pitch, width, height, pSrcBitmap, src_left, src_top, d_plt, pIccTransform)) {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
+bool CFX_DIBitmap::TransferMask(int dest_left, int dest_top, int width, int height,
                                    const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top, int alpha_flag, void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(HasAlpha() && (m_bpp >= 24));
     ASSERT(pMask->IsAlphaMask());
     if (!HasAlpha() || !pMask->IsAlphaMask() || m_bpp < 24) {
-        return FALSE;
+        return false;
     }
     GetOverlapRect(dest_left, dest_top, width, height, pMask->GetWidth(), pMask->GetHeight(), src_left, src_top, NULL);
     if (width == 0 || height == 0) {
-        return TRUE;
+        return true;
     }
     int src_bpp = pMask->GetBPP();
     int alpha;
     FX_DWORD dst_color;
     if (alpha_flag >> 8) {
         alpha = alpha_flag & 0xff;
         dst_color = FXCMYK_TODIB(color);
     } else {
         alpha = FXARGB_A(color);
         dst_color = FXARGB_TODIB(color);
     }
     uint8_t* color_p = (uint8_t*)&dst_color;
     if (pIccTransform && CFX_GEModule::Get()->GetCodecModule() && CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
         ICodec_IccModule* pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
         pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
     } else {
         if (alpha_flag >> 8 && !IsCmykImage())
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color), FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                                color_p[2], color_p[1], color_p[0]);
         else if (!(alpha_flag >> 8) && IsCmykImage()) {
-            return FALSE;
+            return false;
         }
     }
     if(!IsCmykImage()) {
         color_p[3] = (uint8_t)alpha;
     }
     if (GetFormat() == FXDIB_Argb) {
         for (int row = 0; row < height; row ++) {
             FX_DWORD* dest_pos = (FX_DWORD*)(m_pBuffer + (dest_top + row) * m_Pitch + dest_left * 4);
             const uint8_t* src_scan = pMask->GetScanline(src_top + row);
             if (src_bpp == 1) {
@@ skipping 37 matching lines @@
             } else {
                 src_scan += src_left;
                 for (int col = 0; col < width; col ++) {
                     FXSYS_memcpy(dest_color_pos, color_p, comps);
                     dest_color_pos += comps;
                     *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
                 }
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CFX_DIBSource::CopyPalette(const FX_DWORD* pSrc, FX_DWORD size)
 {
     if (pSrc == NULL || GetBPP() > 8) {
         if (m_pPalette) {
             FX_Free(m_pPalette);
         }
         m_pPalette = NULL;
     } else {
         FX_DWORD pal_size = 1 << GetBPP();
@@ skipping 42 matching lines @@
     for (int row = rect.top; row < rect.bottom; row ++) {
         const uint8_t* src_scan = GetScanline(row) + rect.left * 4 + 3;
         uint8_t* dest_scan = (uint8_t*)pMask->GetScanline(row - rect.top);
         for (int col = rect.left; col < rect.right; col ++) {
             *dest_scan ++ = *src_scan;
             src_scan += 4;
         }
     }
     return pMask;
 }
-FX_BOOL CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
+bool CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip)
 {
     if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
-        return FALSE;
+        return false;
     }
     if (pAlphaMask) {
         FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
         if (pClip) {
             rect.Intersect(*pClip);
             if (rect.IsEmpty() || rect.Width() != m_Width || rect.Height() != m_Height) {
-                return FALSE;
+                return false;
             }
         } else {
             if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
-                return FALSE;
+                return false;
             }
         }
         for (int row = 0; row < m_Height; row ++)
             FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),
                            pAlphaMask->GetScanline(row + rect.top) + rect.left, m_pAlphaMask->m_Pitch);
     } else {
         m_pAlphaMask->Clear(0xff000000);
     }
-    return TRUE;
+    return true;
 }
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_DIBSource* pSrcClone = (CFX_DIBSource*)pSrcBitmap;
     CFX_DIBitmap* pDst = this;
     int destOffset, srcOffset;
     if (srcChannel == FXDIB_Alpha) {
         if (!pSrcBitmap->HasAlpha() && !pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (pSrcBitmap->GetBPP() == 1) {
             pSrcClone = pSrcBitmap->CloneConvert(FXDIB_8bppMask);
             if (pSrcClone == NULL) {
-                return FALSE;
+                return false;
             }
         }
         if(pSrcBitmap->GetFormat() == FXDIB_Argb) {
             srcOffset = 3;
         } else {
             srcOffset = 0;
         }
     } else {
         if (pSrcBitmap->IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (pSrcBitmap->GetBPP() < 24) {
             if (pSrcBitmap->IsCmykImage()) {
                 pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x20));
             } else {
                 pSrcClone = pSrcBitmap->CloneConvert((FXDIB_Format)((pSrcBitmap->GetFormat() & 0xff00) | 0x18));
             }
             if (pSrcClone == NULL) {
-                return FALSE;
+                return false;
             }
         }
         srcOffset = g_ChannelOffset[srcChannel];
     }
     if (destChannel == FXDIB_Alpha) {
         if (IsAlphaMask()) {
             if(!ConvertFormat(FXDIB_8bppMask)) {
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             destOffset = 0;
         } else {
             destOffset = 0;
             if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             if (GetFormat() == FXDIB_Argb) {
                 destOffset = 3;
             }
         }
     } else {
         if (IsAlphaMask()) {
             if (pSrcClone != pSrcBitmap) {
                 delete pSrcClone;
             }
-            return FALSE;
+            return false;
         }
         if (GetBPP() < 24) {
             if (HasAlpha()) {
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
             } else
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
 #else
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
 #endif
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
         }
         destOffset = g_ChannelOffset[destChannel];
     }
     if (srcChannel == FXDIB_Alpha && pSrcClone->m_pAlphaMask) {
         CFX_DIBitmap* pAlphaMask = pSrcClone->m_pAlphaMask;
         if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
             if (pAlphaMask) {
                 pAlphaMask = pAlphaMask->StretchTo(m_Width, m_Height);
                 if (pAlphaMask == NULL) {
                     if (pSrcClone != pSrcBitmap) {
                         delete pSrcClone;
                     }
-                    return FALSE;
+                    return false;
                 }
             }
         }
         if (pSrcClone != pSrcBitmap) {
             pSrcClone->m_pAlphaMask = NULL;
             delete pSrcClone;
         }
         pSrcClone = pAlphaMask;
         srcOffset = 0;
     } else if (pSrcClone->GetWidth() != m_Width || pSrcClone->GetHeight() != m_Height) {
         CFX_DIBitmap* pSrcMatched = pSrcClone->StretchTo(m_Width, m_Height);
         if (pSrcClone != pSrcBitmap) {
             delete pSrcClone;
         }
         if (pSrcMatched == NULL) {
-            return FALSE;
+            return false;
         }
         pSrcClone = pSrcMatched;
     }
     if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
         pDst = m_pAlphaMask;
         destOffset = 0;
     }
     int srcBytes = pSrcClone->GetBPP() / 8;
     int destBytes = pDst->GetBPP() / 8;
     for (int row = 0; row < m_Height; row ++) {
         uint8_t* dest_pos = (uint8_t*)pDst->GetScanline(row) + destOffset;
         const uint8_t* src_pos = pSrcClone->GetScanline(row) + srcOffset;
         for (int col = 0; col < m_Width; col ++) {
             *dest_pos = *src_pos;
             dest_pos += destBytes;
             src_pos += srcBytes;
         }
     }
     if (pSrcClone != pSrcBitmap && pSrcClone != pSrcBitmap->m_pAlphaMask) {
         delete pSrcClone;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
+bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel, int value)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     int destOffset;
     if (destChannel == FXDIB_Alpha) {
         if (IsAlphaMask()) {
             if(!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
+                return false;
             }
             destOffset = 0;
         } else {
             destOffset = 0;
             if(!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                return FALSE;
+                return false;
             }
             if (GetFormat() == FXDIB_Argb) {
                 destOffset = 3;
             }
         }
     } else {
         if (IsAlphaMask()) {
-            return FALSE;
+            return false;
         }
         if (GetBPP() < 24) {
             if (HasAlpha()) {
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyka : FXDIB_Argb)) {
-                    return FALSE;
+                    return false;
                 }
             } else
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb)) {
-                    return FALSE;
+                    return false;
                 }
 #else
                 if (!ConvertFormat(IsCmykImage() ? FXDIB_Cmyk : FXDIB_Rgb32)) {
-                    return FALSE;
+                    return false;
                 }
 #endif
         }
         destOffset = g_ChannelOffset[destChannel];
     }
     int Bpp = GetBPP() / 8;
     if (Bpp == 1) {
         FXSYS_memset(m_pBuffer, value, m_Height * m_Pitch);
-        return TRUE;
+        return true;
     }
     if (destChannel == FXDIB_Alpha && m_pAlphaMask) {
         FXSYS_memset(m_pAlphaMask->GetBuffer(), value, m_pAlphaMask->GetHeight()*m_pAlphaMask->GetPitch());
-        return TRUE;
+        return true;
     }
     for (int row = 0; row < m_Height; row ++) {
         uint8_t* scan_line = m_pBuffer + row * m_Pitch + destOffset;
         for (int col = 0; col < m_Width; col ++) {
             *scan_line = value;
             scan_line += Bpp;
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
+bool CFX_DIBitmap::MultiplyAlpha(const CFX_DIBSource* pSrcBitmap)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     ASSERT(pSrcBitmap->IsAlphaMask());
     if (!pSrcBitmap->IsAlphaMask()) {
-        return FALSE;
+        return false;
     }
     if (!IsAlphaMask() && !HasAlpha()) {
         return LoadChannel(FXDIB_Alpha, pSrcBitmap, FXDIB_Alpha);
     }
     CFX_DIBitmap* pSrcClone = (CFX_DIBitmap*)pSrcBitmap;
     if (pSrcBitmap->GetWidth() != m_Width || pSrcBitmap->GetHeight() != m_Height) {
         pSrcClone = pSrcBitmap->StretchTo(m_Width, m_Height);
         ASSERT(pSrcClone != NULL);
         if (pSrcClone == NULL) {
-            return FALSE;
+            return false;
         }
     }
     if (IsAlphaMask()) {
         if(!ConvertFormat(FXDIB_8bppMask)) {
             if (pSrcClone != pSrcBitmap) {
                 delete pSrcClone;
             }
-            return FALSE;
+            return false;
         }
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* dest_scan = m_pBuffer + m_Pitch * row;
             uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
             if (pSrcClone->GetBPP() == 1) {
                 for (int col = 0; col < m_Width; col ++) {
                     if (!((1 << (7 - col % 8)) & src_scan[col / 8])) {
                         dest_scan[col] = 0;
                     }
                 }
             } else {
                 for (int col = 0; col < m_Width; col ++) {
                     *dest_scan = (*dest_scan) * src_scan[col] / 255;
                     dest_scan ++;
                 }
             }
         }
     } else {
         if(GetFormat() == FXDIB_Argb) {
             if (pSrcClone->GetBPP() == 1) {
                 if (pSrcClone != pSrcBitmap) {
                     delete pSrcClone;
                 }
-                return FALSE;
+                return false;
             }
             for (int row = 0; row < m_Height; row ++) {
                 uint8_t* dest_scan = m_pBuffer + m_Pitch * row + 3;
                 uint8_t* src_scan = pSrcClone->m_pBuffer + pSrcClone->m_Pitch * row;
                 for (int col = 0; col < m_Width; col ++) {
                     *dest_scan = (*dest_scan) * src_scan[col] / 255;
                     dest_scan += 4;
                 }
             }
         } else {
             m_pAlphaMask->MultiplyAlpha(pSrcClone);
         }
     }
     if (pSrcClone != pSrcBitmap) {
         delete pSrcClone;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::GetGrayData(void* pIccTransform)
+bool CFX_DIBitmap::GetGrayData(void* pIccTransform)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     switch (GetFormat()) {
         case FXDIB_1bppRgb: {
                 if (m_pPalette == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 uint8_t gray[2];
                 for (int i = 0; i < 2; i ++) {
                     int r = (uint8_t)(m_pPalette[i] >> 16);
                     int g = (uint8_t)(m_pPalette[i] >> 8);
                     int b = (uint8_t)m_pPalette[i];
                     gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
                 }
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 FXSYS_memset(pMask->GetBuffer(), gray[0], pMask->GetPitch() * m_Height);
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
                     uint8_t* dest_pos = (uint8_t*)pMask->GetScanline(row);
                     for (int col = 0; col < m_Width; col ++) {
                         if (src_pos[col / 8] & (1 << (7 - col % 8))) {
                             *dest_pos = gray[1];
                         }
                         dest_pos ++;
                     }
                 }
                 TakeOver(pMask);
                 delete pMask;
                 break;
             }
         case FXDIB_8bppRgb: {
                 if (m_pPalette == NULL) {
-                    return FALSE;
+                    return false;
                 }
                 uint8_t gray[256];
                 for (int i = 0; i < 256; i ++) {
                     int r = (uint8_t)(m_pPalette[i] >> 16);
                     int g = (uint8_t)(m_pPalette[i] >> 8);
                     int b = (uint8_t)m_pPalette[i];
                     gray[i] = (uint8_t)FXRGB2GRAY(r, g, b);
                 }
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
                     for (int col = 0; col < m_Width; col ++) {
                         *dest_pos ++ = gray[*src_pos ++];
                     }
                 }
                 TakeOver(pMask);
                 delete pMask;
                 break;
             }
         case FXDIB_Rgb: {
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
                     uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
                     for (int col = 0; col < m_Width; col ++) {
                         *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
                         src_pos += 3;
                     }
                 }
                 TakeOver(pMask);
                 delete pMask;
                 break;
             }
         case FXDIB_Rgb32: {
                 CFX_DIBitmap* pMask = new CFX_DIBitmap;
                 if (!pMask->Create(m_Width, m_Height, FXDIB_8bppMask)) {
                     delete pMask;
-                    return FALSE;
+                    return false;
                 }
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* src_pos = m_pBuffer + row * m_Pitch;
                     uint8_t* dest_pos = pMask->GetBuffer() + row * pMask->GetPitch();
                     for (int col = 0; col < m_Width; col ++) {
                         *dest_pos ++ = FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos);
                         src_pos += 4;
                     }
                 }
                 TakeOver(pMask);
                 delete pMask;
                 break;
             }
         default:
-            return FALSE;
+            return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::MultiplyAlpha(int alpha)
+bool CFX_DIBitmap::MultiplyAlpha(int alpha)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     switch (GetFormat()) {
         case FXDIB_1bppMask:
             if (!ConvertFormat(FXDIB_8bppMask)) {
-                return FALSE;
+                return false;
             }
             MultiplyAlpha(alpha);
             break;
         case FXDIB_8bppMask: {
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* scan_line = m_pBuffer + row * m_Pitch;
                     for (int col = 0; col < m_Width; col ++) {
                         scan_line[col] = scan_line[col] * alpha / 255;
                     }
                 }
                 break;
             }
         case FXDIB_Argb: {
                 for (int row = 0; row < m_Height; row ++) {
                     uint8_t* scan_line = m_pBuffer + row * m_Pitch + 3;
                     for (int col = 0; col < m_Width; col ++) {
                         *scan_line = (*scan_line) * alpha / 255;
                         scan_line += 4;
                     }
                 }
                 break;
             }
         default:
             if (HasAlpha()) {
                 m_pAlphaMask->MultiplyAlpha(alpha);
             } else if (IsCmykImage()) {
                 if (!ConvertFormat((FXDIB_Format)(GetFormat() | 0x0200))) {
-                    return FALSE;
+                    return false;
                 }
                 m_pAlphaMask->MultiplyAlpha(alpha);
             } else {
                 if (!ConvertFormat(FXDIB_Argb)) {
-                    return FALSE;
+                    return false;
                 }
                 MultiplyAlpha(alpha);
             }
             break;
     }
-    return TRUE;
+    return true;
 }
 FX_DWORD CFX_DIBitmap::GetPixel(int x, int y) const
 {
     if (m_pBuffer == NULL) {
         return 0;
     }
     uint8_t* pos = m_pBuffer + y * m_Pitch + x * GetBPP() / 8;
     switch (GetFormat()) {
         case FXDIB_1bppMask: {
                 if ((*pos) & (1 << (7 - x % 8))) {
@@ skipping 88 matching lines @@
                 break;
             }
         case FXDIB_Argb:
             FXARGB_SETDIB(pos, color);
             break;
         default:
             break;
     }
 }
 void CFX_DIBitmap::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-                                      int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
+                                      int dest_width, bool bFlipX, int clip_left, int clip_width) const
 {
     if (m_pBuffer == NULL) {
         return;
     }
     int src_Bpp = m_bpp / 8;
     uint8_t* scanline = m_pBuffer + line * m_Pitch;
     if (src_Bpp == 0) {
         for (int i = 0; i < clip_width; i ++) {
             FX_DWORD dest_x = clip_left + i;
             FX_DWORD src_x = dest_x * m_Width / dest_width;
@@ skipping 36 matching lines @@
             FX_DWORD dest_x = clip_left + i;
             FX_DWORD src_x = bFlipX ? (m_Width - dest_x * m_Width / dest_width - 1) * src_Bpp : (dest_x * m_Width / dest_width) * src_Bpp;
             src_x %= m_Width * src_Bpp;
             int dest_pos = i * src_Bpp;
             for (int b = 0; b < src_Bpp; b ++) {
                 dest_scan[dest_pos + b] = scanline[src_x + b];
             }
         }
     }
 }
-FX_BOOL CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
+bool CFX_DIBitmap::ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor)
 {
     ASSERT(!IsAlphaMask());
     if (m_pBuffer == NULL || IsAlphaMask()) {
-        return FALSE;
+        return false;
     }
     int fc, fm, fy, fk, bc, bm, by, bk;
     int fr, fg, fb, br, bg, bb;
-    FX_BOOL isCmykImage = IsCmykImage();
+    bool isCmykImage = IsCmykImage();
     if (isCmykImage) {
         fc = FXSYS_GetCValue(forecolor);
         fm = FXSYS_GetMValue(forecolor);
         fy = FXSYS_GetYValue(forecolor);
         fk = FXSYS_GetKValue(forecolor);
         bc = FXSYS_GetCValue(backcolor);
         bm = FXSYS_GetMValue(backcolor);
         by = FXSYS_GetYValue(backcolor);
         bk = FXSYS_GetKValue(backcolor);
     } else {
         fr = FXSYS_GetRValue(forecolor);
         fg = FXSYS_GetGValue(forecolor);
         fb = FXSYS_GetBValue(forecolor);
         br = FXSYS_GetRValue(backcolor);
         bg = FXSYS_GetGValue(backcolor);
         bb = FXSYS_GetBValue(backcolor);
     }
     if (m_bpp <= 8) {
         if (isCmykImage) {
             if (forecolor == 0xff && backcolor == 0 && m_pPalette == NULL) {
-                return TRUE;
+                return true;
             }
         } else if (forecolor == 0 && backcolor == 0xffffff && m_pPalette == NULL) {
-            return TRUE;
+            return true;
         }
         if (m_pPalette == NULL) {
             BuildPalette();
         }
         int size = 1 << m_bpp;
         if (isCmykImage) {
             for (int i = 0; i < size; i ++) {
                 uint8_t b, g, r;
                 AdobeCMYK_to_sRGB1(FXSYS_GetCValue(m_pPalette[i]), FXSYS_GetMValue(m_pPalette[i]), FXSYS_GetYValue(m_pPalette[i]), FXSYS_GetKValue(m_pPalette[i]),
                                    r, g, b);
                 int gray = 255 - FXRGB2GRAY(r, g, b);
                 m_pPalette[i] = CmykEncode(bc + (fc - bc) * gray / 255, bm + (fm - bm) * gray / 255,
                                            by + (fy - by) * gray / 255, bk + (fk - bk) * gray / 255);
             }
         } else
             for (int i = 0; i < size; i ++) {
                 int gray = FXRGB2GRAY(FXARGB_R(m_pPalette[i]), FXARGB_G(m_pPalette[i]), FXARGB_B(m_pPalette[i]));
                 m_pPalette[i] = FXARGB_MAKE(0xff, br + (fr - br) * gray / 255, bg + (fg - bg) * gray / 255,
                                             bb + (fb - bb) * gray / 255);
             }
-        return TRUE;
+        return true;
     }
     if (isCmykImage) {
         if (forecolor == 0xff && backcolor == 0x00) {
             for (int row = 0; row < m_Height; row ++) {
                 uint8_t* scanline = m_pBuffer + row * m_Pitch;
                 for (int col = 0; col < m_Width; col ++) {
                     uint8_t b, g, r;
                     AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                                        r, g, b);
                     *scanline ++ = 0;
                     *scanline ++ = 0;
                     *scanline ++ = 0;
                     *scanline ++ = 255 - FXRGB2GRAY(r, g, b);
                 }
             }
-            return TRUE;
+            return true;
         }
     } else if (forecolor == 0 && backcolor == 0xffffff) {
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* scanline = m_pBuffer + row * m_Pitch;
             int gap = m_bpp / 8 - 2;
             for (int col = 0; col < m_Width; col ++) {
                 int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
                 *scanline ++ = gray;
                 *scanline ++ = gray;
                 *scanline    = gray;
                 scanline += gap;
             }
         }
-        return TRUE;
+        return true;
     }
     if (isCmykImage) {
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* scanline = m_pBuffer + row * m_Pitch;
             for (int col = 0; col < m_Width; col ++) {
                 uint8_t b, g, r;
                 AdobeCMYK_to_sRGB1(scanline[0], scanline[1], scanline[2], scanline[3],
                                    r, g, b);
                 int gray = 255 - FXRGB2GRAY(r, g, b);
                 *scanline ++ = bc + (fc - bc) * gray / 255;
                 *scanline ++ = bm + (fm - bm) * gray / 255;
                 *scanline ++ = by + (fy - by) * gray / 255;
                 *scanline ++ = bk + (fk - bk) * gray / 255;
             }
         }
     } else {
         for (int row = 0; row < m_Height; row ++) {
             uint8_t* scanline = m_pBuffer + row * m_Pitch;
             int gap = m_bpp / 8 - 2;
             for (int col = 0; col < m_Width; col ++) {
                 int gray = FXRGB2GRAY(scanline[2], scanline[1], scanline[0]);
                 *scanline ++ = bb + (fb - bb) * gray / 255;
                 *scanline ++ = bg + (fg - bg) * gray / 255;
                 *scanline    = br + (fr - br) * gray / 255;
                 scanline += gap;
             }
         }
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
+bool CFX_DIBitmap::DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect)
 {
     if (m_pBuffer == NULL) {
-        return FALSE;
+        return false;
     }
     if (m_bpp != 8 && m_pPalette != NULL && m_AlphaFlag != 0) {
-        return FALSE;
+        return false;
     }
     if (m_Width < 4 && m_Height < 4) {
-        return FALSE;
+        return false;
     }
     FX_RECT rect(0, 0, m_Width, m_Height);
     if (pRect) {
         rect.Intersect(*pRect);
     }
     uint8_t translate[256];
     for (int i = 0; i < 256; i ++) {
         int err2 = 65536;
         for (int j = 0; j < pal_size; j ++) {
             uint8_t entry = (uint8_t)pPalette[j];
@@ skipping 51 matching lines @@
                 if (src > 255) {
                     next_scan[col - 1] = 255;
                 } else if (src < 0) {
                     next_scan[col - 1] = 0;
                 } else {
                     next_scan[col - 1] = src;
                 }
             }
         }
     }
-    return TRUE;
+    return true;
 }
-CFX_DIBitmap* CFX_DIBSource::FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const
+CFX_DIBitmap* CFX_DIBSource::FlipImage(bool bXFlip, bool bYFlip) const
 {
     CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
     if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
         delete pFlipped;
         return NULL;
     }
     pFlipped->CopyPalette(m_pPalette);
     uint8_t* pDestBuffer = pFlipped->GetBuffer();
     int Bpp = m_bpp / 8;
     for (int row = 0; row < m_Height; row ++) {
@@ skipping 83 matching lines @@
 }
 CFX_FilteredDIB::~CFX_FilteredDIB()
 {
     if (m_bAutoDropSrc) {
         delete m_pSrc;
     }
     if (m_pScanline) {
         FX_Free(m_pScanline);
     }
 }
-void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc)
+void CFX_FilteredDIB::LoadSrc(const CFX_DIBSource* pSrc, bool bAutoDropSrc)
 {
     m_pSrc = pSrc;
     m_bAutoDropSrc = bAutoDropSrc;
     m_Width = pSrc->GetWidth();
     m_Height = pSrc->GetHeight();
     FXDIB_Format format = GetDestFormat();
     m_bpp = (uint8_t)format;
     m_AlphaFlag = (uint8_t)(format >> 8);
     m_Pitch = (m_Width * (format & 0xff) + 31) / 32 * 4;
     m_pPalette = GetDestPalette();
     m_pScanline = FX_Alloc(uint8_t, m_Pitch);
 }
 const uint8_t* CFX_FilteredDIB::GetScanline(int line) const
 {
     TranslateScanline(m_pScanline, m_pSrc->GetScanline(line));
     return m_pScanline;
 }
 void CFX_FilteredDIB::DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-        int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
+        int dest_width, bool bFlipX, int clip_left, int clip_width) const
 {
     m_pSrc->DownSampleScanline(line, dest_scan, dest_bpp, dest_width, bFlipX, clip_left, clip_width);
     TranslateDownSamples(dest_scan, dest_scan, clip_width, dest_bpp);
 }
 CFX_ImageRenderer::CFX_ImageRenderer()
 {
     m_Status = 0;
     m_pTransformer = NULL;
-    m_bRgbByteOrder = FALSE;
+    m_bRgbByteOrder = false;
     m_BlendType = FXDIB_BLEND_NORMAL;
 }
 CFX_ImageRenderer::~CFX_ImageRenderer()
 {
     delete m_pTransformer;
 }
-extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, FX_BOOL bFlipX, FX_BOOL bFlipY);
-FX_BOOL CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
+extern FX_RECT _FXDIB_SwapClipBox(FX_RECT& clip, int width, int height, bool bFlipX, bool bFlipY);
+bool CFX_ImageRenderer::Start(CFX_DIBitmap* pDevice, const CFX_ClipRgn* pClipRgn,
                                  const CFX_DIBSource* pSource, int bitmap_alpha,
                                  FX_DWORD mask_color, const CFX_AffineMatrix* pMatrix,
-                                 FX_DWORD dib_flags, FX_BOOL bRgbByteOrder,
+                                 FX_DWORD dib_flags, bool bRgbByteOrder,
                                  int alpha_flag, void* pIccTransform, int blend_type)
 {
     m_Matrix = *pMatrix;
     CFX_FloatRect image_rect_f = m_Matrix.GetUnitRect();
     FX_RECT image_rect = image_rect_f.GetOutterRect();
     m_ClipBox = pClipRgn ? pClipRgn->GetBox() : FX_RECT(0, 0, pDevice->GetWidth(), pDevice->GetHeight());
     m_ClipBox.Intersect(image_rect);
     if (m_ClipBox.IsEmpty()) {
-        return FALSE;
+        return false;
     }
     m_pDevice = pDevice;
     m_pClipRgn = pClipRgn;
     m_MaskColor = mask_color;
     m_BitmapAlpha = bitmap_alpha;
     m_Matrix = *pMatrix;
     m_Flags = dib_flags;
     m_AlphaFlag = alpha_flag;
     m_pIccTransform = pIccTransform;
     m_bRgbByteOrder = bRgbByteOrder;
     m_BlendType = blend_type;
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if ((FXSYS_fabs(m_Matrix.b) >= 0.5f || m_Matrix.a == 0) ||
             (FXSYS_fabs(m_Matrix.c) >= 0.5f || m_Matrix.d == 0) ) {
         if (FXSYS_fabs(m_Matrix.a) < FXSYS_fabs(m_Matrix.b) / 20 && FXSYS_fabs(m_Matrix.d) < FXSYS_fabs(m_Matrix.c) / 20 &&
                 FXSYS_fabs(m_Matrix.a) < 0.5f && FXSYS_fabs(m_Matrix.d) < 0.5f) {
             int dest_width = image_rect.Width();
             int dest_height = image_rect.Height();
             FX_RECT bitmap_clip = m_ClipBox;
             bitmap_clip.Offset(-image_rect.left, -image_rect.top);
             bitmap_clip = _FXDIB_SwapClipBox(bitmap_clip, dest_width, dest_height, m_Matrix.c > 0, m_Matrix.b < 0);
-            m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, TRUE,
+            m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color, m_ClipBox, true,
                                m_Matrix.c > 0, m_Matrix.b < 0, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
             if (!m_Stretcher.Start(&m_Composer, pSource, dest_height, dest_width, bitmap_clip, dib_flags)) {
-                return FALSE;
+                return false;
             }
             m_Status = 1;
-            return TRUE;
+            return true;
         }
         m_Status = 2;
         m_pTransformer = new CFX_ImageTransformer;
         m_pTransformer->Start(pSource, &m_Matrix, dib_flags, &m_ClipBox);
-        return TRUE;
+        return true;
     }
     int dest_width = image_rect.Width();
     if (m_Matrix.a < 0) {
         dest_width = -dest_width;
     }
     int dest_height = image_rect.Height();
     if (m_Matrix.d > 0) {
         dest_height = -dest_height;
     }
     if (dest_width == 0 || dest_height == 0) {
-        return FALSE;
+        return false;
     }
     FX_RECT bitmap_clip = m_ClipBox;
     bitmap_clip.Offset(-image_rect.left, -image_rect.top);
     m_Composer.Compose(pDevice, pClipRgn, bitmap_alpha, mask_color,
-                       m_ClipBox, FALSE, FALSE, FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
+                       m_ClipBox, false, false, false, m_bRgbByteOrder, alpha_flag, pIccTransform, m_BlendType);
     m_Status = 1;
     ret = m_Stretcher.Start(&m_Composer, pSource, dest_width, dest_height, bitmap_clip, dib_flags);
     return ret;
 }
-FX_BOOL CFX_ImageRenderer::Continue(IFX_Pause* pPause)
+bool CFX_ImageRenderer::Continue(IFX_Pause* pPause)
 {
     if (m_Status == 1) {
         return m_Stretcher.Continue(pPause);
     } else if (m_Status == 2) {
         if (m_pTransformer->Continue(pPause)) {
-            return TRUE;
+            return true;
         }
         CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
         if (pBitmap == NULL) {
-            return FALSE;
+            return false;
         }
         if (pBitmap->GetBuffer() == NULL) {
             delete pBitmap;
-            return FALSE;
+            return false;
         }
         if (pBitmap->IsAlphaMask()) {
             if (m_BitmapAlpha != 255) {
                 if (m_AlphaFlag >> 8) {
                     m_AlphaFlag = (((uint8_t)((m_AlphaFlag & 0xff) * m_BitmapAlpha / 255)) | ((m_AlphaFlag >> 8) << 8));
                 } else {
                     m_MaskColor = FXARGB_MUL_ALPHA(m_MaskColor, m_BitmapAlpha);
                 }
             }
             m_pDevice->CompositeMask(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
                                      pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, m_MaskColor,
                                      0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_AlphaFlag, m_pIccTransform);
         } else {
             if (m_BitmapAlpha != 255) {
                 pBitmap->MultiplyAlpha(m_BitmapAlpha);
             }
             m_pDevice->CompositeBitmap(m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
                                        pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap, 0, 0, m_BlendType, m_pClipRgn, m_bRgbByteOrder, m_pIccTransform);
         }
         delete pBitmap;
-        return FALSE;
+        return false;
     }
-    return FALSE;
+    return false;
 }
 CFX_BitmapStorer::CFX_BitmapStorer()
 {
     m_pBitmap = NULL;
 }
 CFX_BitmapStorer::~CFX_BitmapStorer()
 {
     delete m_pBitmap;
 }
 CFX_DIBitmap* CFX_BitmapStorer::Detach()
@@ skipping 12 matching lines @@
     uint8_t* dest_buf = (uint8_t*)m_pBitmap->GetScanline(line);
     uint8_t* dest_alpha_buf = m_pBitmap->m_pAlphaMask ?
                                (uint8_t*)m_pBitmap->m_pAlphaMask->GetScanline(line) : NULL;
     if (dest_buf) {
         FXSYS_memcpy(dest_buf, scanline, m_pBitmap->GetPitch());
     }
     if (dest_alpha_buf) {
         FXSYS_memcpy(dest_alpha_buf, scan_extra_alpha, m_pBitmap->m_pAlphaMask->GetPitch());
     }
 }
-FX_BOOL CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
+bool CFX_BitmapStorer::SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette)
 {
     m_pBitmap = new CFX_DIBitmap;
     if (!m_pBitmap->Create(width, height, src_format)) {
         delete m_pBitmap;
         m_pBitmap = NULL;
-        return FALSE;
+        return false;
     }
     if (pSrcPalette) {
         m_pBitmap->CopyPalette(pSrcPalette);
     }
-    return TRUE;
+    return true;
 }