FX_BOOL considered harmful.

core/include/fxge/fx_dib.h

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #ifndef CORE_INCLUDE_FXGE_FX_DIB_H_
 #define CORE_INCLUDE_FXGE_FX_DIB_H_
 
 #include "../fxcrt/fx_basic.h"
@@ skipping 161 matching lines @@
 
 
 
     virtual     uint8_t*        GetBuffer() const
     {
         return NULL;
     }
 
     virtual const uint8_t*      GetScanline(int line) const = 0;
 
-    virtual FX_BOOL             SkipToScanline(int line, IFX_Pause* pPause) const
+    virtual bool                SkipToScanline(int line, IFX_Pause* pPause) const
     {
-        return FALSE;
+        return false;
     }
 
     virtual void                DownSampleScanline(int line, uint8_t* dest_scan, int dest_bpp,
-                                           int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const = 0;
+                                           int dest_width, bool bFlipX, int clip_left, int clip_width) const = 0;
 
     virtual void                SetDownSampleSize(int width, int height) const {}
 
     int                         GetBPP() const
     {
         return m_bpp;
     }
 
-    FX_BOOL                     IsAlphaMask() const
+    bool                        IsAlphaMask() const
     {
         return m_AlphaFlag == 1;
     }
 
-    FX_BOOL                     HasAlpha() const
+    bool                        HasAlpha() const
     {
-        return m_AlphaFlag & 2 ? TRUE : FALSE;
+        return m_AlphaFlag & 2 ? true : false;
     }
 
-    FX_BOOL                     IsOpaqueImage() const
+    bool                        IsOpaqueImage() const
     {
         return !(m_AlphaFlag & 3);
     }
 
-    FX_BOOL                     IsCmykImage() const
+    bool                        IsCmykImage() const
     {
-        return m_AlphaFlag & 4 ? TRUE : FALSE;
+        return m_AlphaFlag & 4 ? true : false;
     }
 
 
 
     int                         GetPaletteSize() const
     {
         return IsAlphaMask() ? 0 : (m_bpp == 1 ? 2 : (m_bpp == 8 ? 256 : 0));
     }
 
     FX_DWORD            GetPaletteEntry(int index) const;
@@ skipping 16 matching lines @@
     CFX_DIBitmap*       CloneConvert(FXDIB_Format format, const FX_RECT* pClip = NULL, void* pIccTransform = NULL) const;
 
     CFX_DIBitmap*       StretchTo(int dest_width, int dest_height, FX_DWORD flags = 0, const FX_RECT* pClip = NULL) const;
 
 
     CFX_DIBitmap*       TransformTo(const CFX_AffineMatrix* pMatrix, int& left, int &top,
                                 FX_DWORD flags = 0, const FX_RECT* pClip = NULL) const;
 
     CFX_DIBitmap*       GetAlphaMask(const FX_RECT* pClip = NULL) const;
 
-    FX_BOOL                     CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip = NULL);
+    bool                        CopyAlphaMask(const CFX_DIBSource* pAlphaMask, const FX_RECT* pClip = NULL);
 
-    CFX_DIBitmap*       SwapXY(FX_BOOL bXFlip, FX_BOOL bYFlip, const FX_RECT* pClip = NULL) const;
+    CFX_DIBitmap*       SwapXY(bool bXFlip, bool bYFlip, const FX_RECT* pClip = NULL) const;
 
-    CFX_DIBitmap*       FlipImage(FX_BOOL bXFlip, FX_BOOL bYFlip) const;
+    CFX_DIBitmap*       FlipImage(bool bXFlip, bool bYFlip) const;
 
     void                        GetOverlapRect(int& dest_left, int& dest_top, int& width, int& height, int src_width,
                                    int src_height, int& src_left, int& src_top, const CFX_ClipRgn* pClipRgn);
 
     CFX_DIBitmap*       m_pAlphaMask;
 protected:
 
     CFX_DIBSource();
 
     int                         m_Width;
 
     int                         m_Height;
 
     int                         m_bpp;
 
     FX_DWORD            m_AlphaFlag;
 
     FX_DWORD            m_Pitch;
 
     FX_DWORD*           m_pPalette;
 
     void                        BuildPalette();
 
-    FX_BOOL                     BuildAlphaMask();
+    bool                        BuildAlphaMask();
 
     int                         FindPalette(FX_DWORD color) const;
 
     void                        GetPalette(FX_DWORD* pal, int alpha) const;
 };
 class CFX_DIBitmap : public CFX_DIBSource
 {
 public:
 
     virtual ~CFX_DIBitmap();
 
     CFX_DIBitmap();
 
     CFX_DIBitmap(const CFX_DIBitmap& src);
 
-    FX_BOOL                     Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer = NULL, int pitch = 0);
+    bool                        Create(int width, int height, FXDIB_Format format, uint8_t* pBuffer = NULL, int pitch = 0);
 
-    FX_BOOL                     Copy(const CFX_DIBSource* pSrc);
+    bool                        Copy(const CFX_DIBSource* pSrc);
 
     virtual     uint8_t*        GetBuffer() const
     {
         return m_pBuffer;
     }
 
     virtual const uint8_t*      GetScanline(int line) const
     {
         return m_pBuffer ? m_pBuffer + line * m_Pitch : NULL;
     }
 
     virtual void        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;
 
     void                        TakeOver(CFX_DIBitmap* pSrcBitmap);
 
-    FX_BOOL                     ConvertFormat(FXDIB_Format format, void* pIccTransform = NULL);
+    bool                        ConvertFormat(FXDIB_Format format, void* pIccTransform = NULL);
 
     void                        Clear(FX_DWORD color);
 
     FX_DWORD            GetPixel(int x, int y) const;
 
     void                        SetPixel(int x, int y, FX_DWORD color);
 
-    FX_BOOL                     LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel);
+    bool                        LoadChannel(FXDIB_Channel destChannel, const CFX_DIBSource* pSrcBitmap, FXDIB_Channel srcChannel);
 
-    FX_BOOL                     LoadChannel(FXDIB_Channel destChannel, int value);
+    bool                        LoadChannel(FXDIB_Channel destChannel, int value);
 
-    FX_BOOL                     MultiplyAlpha(int alpha);
+    bool                        MultiplyAlpha(int alpha);
 
-    FX_BOOL                     MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
+    bool                        MultiplyAlpha(const CFX_DIBSource* pAlphaMask);
 
-    FX_BOOL                     TransferBitmap(int dest_left, int dest_top, int width, int height,
+    bool                        TransferBitmap(int dest_left, int dest_top, int width, int height,
                                    const CFX_DIBSource* pSrcBitmap, int src_left, int src_top, void* pIccTransform = NULL);
 
-    FX_BOOL                     CompositeBitmap(int dest_left, int dest_top, int width, int height,
+    bool                        CompositeBitmap(int dest_left, int dest_top, int width, int height,
                                     const CFX_DIBSource* pSrcBitmap, int src_left, int src_top,
-                                    int blend_type = FXDIB_BLEND_NORMAL, const CFX_ClipRgn* pClipRgn = NULL, FX_BOOL bRgbByteOrder = FALSE, void* pIccTransform = NULL);
+                                    int blend_type = FXDIB_BLEND_NORMAL, const CFX_ClipRgn* pClipRgn = NULL, bool bRgbByteOrder = false, void* pIccTransform = NULL);
 
-    FX_BOOL                     TransferMask(int dest_left, int dest_top, int width, int height,
+    bool                        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 = 0, void* pIccTransform = NULL);
 
-    FX_BOOL                     CompositeMask(int dest_left, int dest_top, int width, int height,
+    bool                        CompositeMask(int dest_left, int dest_top, int width, int height,
                                   const CFX_DIBSource* pMask, FX_DWORD color, int src_left, int src_top,
-                                  int blend_type = FXDIB_BLEND_NORMAL, const CFX_ClipRgn* pClipRgn = NULL, FX_BOOL bRgbByteOrder = FALSE, int alpha_flag = 0, void* pIccTransform = NULL);
+                                  int blend_type = FXDIB_BLEND_NORMAL, const CFX_ClipRgn* pClipRgn = NULL, bool bRgbByteOrder = false, int alpha_flag = 0, void* pIccTransform = NULL);
 
-    FX_BOOL                     CompositeRect(int dest_left, int dest_top, int width, int height, FX_DWORD color, int alpha_flag = 0, void* pIccTransform = NULL);
+    bool                        CompositeRect(int dest_left, int dest_top, int width, int height, FX_DWORD color, int alpha_flag = 0, void* pIccTransform = NULL);
 
-    FX_BOOL                     ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor);
+    bool                        ConvertColorScale(FX_DWORD forecolor, FX_DWORD backcolor);
 
-    FX_BOOL                     DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect = NULL);
+    bool                        DitherFS(const FX_DWORD* pPalette, int pal_size, const FX_RECT* pRect = NULL);
 protected:
 
     uint8_t*            m_pBuffer;
 
-    FX_BOOL                     m_bExtBuf;
+    bool                        m_bExtBuf;
 
-    FX_BOOL                     GetGrayData(void* pIccTransform = NULL);
+    bool                        GetGrayData(void* pIccTransform = NULL);
 };
 class CFX_DIBExtractor
 {
 public:
 
     CFX_DIBExtractor(const CFX_DIBSource* pSrc);
 
     ~CFX_DIBExtractor();
 
     operator CFX_DIBitmap*()
     {
         return m_pBitmap;
     }
 private:
 
     CFX_DIBitmap*                       m_pBitmap;
 };
 typedef CFX_CountRef<CFX_DIBitmap> CFX_DIBitmapRef;
 class CFX_FilteredDIB : public CFX_DIBSource
 {
 public:
 
     CFX_FilteredDIB();
 
     ~CFX_FilteredDIB();
 
-    void                                        LoadSrc(const CFX_DIBSource* pSrc, FX_BOOL bAutoDropSrc = FALSE);
+    void                                        LoadSrc(const CFX_DIBSource* pSrc, bool bAutoDropSrc = false);
 
     virtual FXDIB_Format        GetDestFormat() = 0;
 
     virtual FX_DWORD*           GetDestPalette() = 0;
 
 
     virtual void                        TranslateScanline(uint8_t* dest_buf, const uint8_t* src_buf) const = 0;
 
     virtual void                        TranslateDownSamples(uint8_t* dest_buf, const uint8_t* src_buf, int pixels, int Bpp) const = 0;
 protected:
     virtual const uint8_t*              GetScanline(int line) const;
     virtual void                        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;
 
     const CFX_DIBSource*        m_pSrc;
 
-    FX_BOOL                                     m_bAutoDropSrc;
+    bool                                        m_bAutoDropSrc;
 
     uint8_t*                            m_pScanline;
 };
 class IFX_ScanlineComposer
 {
 public:
     virtual ~IFX_ScanlineComposer() { }
 
     virtual     void            ComposeScanline(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha = NULL) = 0;
 
-    virtual FX_BOOL             SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette) = 0;
+    virtual bool                SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette) = 0;
 };
 class CFX_ScanlineCompositor
 {
 public:
     CFX_ScanlineCompositor();
 
     ~CFX_ScanlineCompositor();
 
-    FX_BOOL                             Init(FXDIB_Format dest_format, FXDIB_Format src_format, int32_t width, FX_DWORD* pSrcPalette,
-                             FX_DWORD mask_color, int blend_type, FX_BOOL bClip, FX_BOOL bRgbByteOrder = FALSE, int alpha_flag = 0, void* pIccTransform = NULL);
+    bool                                Init(FXDIB_Format dest_format, FXDIB_Format src_format, int32_t width, FX_DWORD* pSrcPalette,
+                             FX_DWORD mask_color, int blend_type, bool bClip, bool bRgbByteOrder = false, int alpha_flag = 0, void* pIccTransform = NULL);
 
 
     void                                CompositeRgbBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int width, const uint8_t* clip_scan,
             const uint8_t* src_extra_alpha = NULL, uint8_t* dst_extra_alpha = NULL);
 
 
     void                                CompositePalBitmapLine(uint8_t* dest_scan, const uint8_t* src_scan, int src_left, int width, const uint8_t* clip_scan,
             const uint8_t* src_extra_alpha = NULL, uint8_t* dst_extra_alpha = NULL);
 
 
@@ skipping 11 matching lines @@
 
     int                                 m_MaskAlpha,
                         m_MaskRed,
                         m_MaskGreen,
                         m_MaskBlue,
                         m_MaskBlack;
     int                                 m_BlendType;
     void*                               m_pIccTransform;
     uint8_t*                    m_pCacheScanline;
     int                                 m_CacheSize;
-    FX_BOOL             m_bRgbByteOrder;
+    bool             m_bRgbByteOrder;
 };
 class CFX_BitmapComposer : public IFX_ScanlineComposer
 {
 public:
 
     CFX_BitmapComposer();
 
     ~CFX_BitmapComposer();
 
 
     void                                Compose(CFX_DIBitmap* pDest, const CFX_ClipRgn* pClipRgn, int bitmap_alpha,
-                                FX_DWORD mask_color, FX_RECT& dest_rect, FX_BOOL bVertical,
-                                FX_BOOL bFlipX, FX_BOOL bFlipY, FX_BOOL bRgbByteOrder = FALSE,
+                                FX_DWORD mask_color, FX_RECT& dest_rect, bool bVertical,
+                                bool bFlipX, bool bFlipY, bool bRgbByteOrder = false,
                                 int alpha_flag = 0, void* pIccTransform = NULL, int blend_type = FXDIB_BLEND_NORMAL);
 
-    virtual FX_BOOL             SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette);
+    virtual bool                SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette);
 
 
     virtual     void            ComposeScanline(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha);
 protected:
 
     void                                DoCompose(uint8_t* dest_scan, const uint8_t* src_scan, int dest_width, const uint8_t* clip_scan,
                                   const uint8_t* src_extra_alpha = NULL, uint8_t* dst_extra_alpha = NULL);
     CFX_DIBitmap*               m_pBitmap;
     const CFX_ClipRgn*  m_pClipRgn;
     FXDIB_Format                m_SrcFormat;
     int                                 m_DestLeft, m_DestTop, m_DestWidth, m_DestHeight, m_BitmapAlpha;
     FX_DWORD                    m_MaskColor;
     const CFX_DIBitmap* m_pClipMask;
     CFX_ScanlineCompositor      m_Compositor;
-    FX_BOOL                             m_bVertical, m_bFlipX, m_bFlipY;
+    bool                                m_bVertical, m_bFlipX, m_bFlipY;
     int                                 m_AlphaFlag;
     void*                               m_pIccTransform;
-    FX_BOOL             m_bRgbByteOrder;
+    bool             m_bRgbByteOrder;
     int                                 m_BlendType;
     void                                ComposeScanlineV(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha = NULL);
     uint8_t* m_pScanlineV;
     uint8_t* m_pClipScanV;
     uint8_t* m_pAddClipScan;
     uint8_t* m_pScanlineAlphaV;
 };
 class CFX_BitmapStorer : public IFX_ScanlineComposer
 {
 public:
 
     CFX_BitmapStorer();
 
     ~CFX_BitmapStorer();
 
     virtual     void            ComposeScanline(int line, const uint8_t* scanline, const uint8_t* scan_extra_alpha);
 
-    virtual FX_BOOL             SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette);
+    virtual bool                SetInfo(int width, int height, FXDIB_Format src_format, FX_DWORD* pSrcPalette);
 
     CFX_DIBitmap*               GetBitmap()
     {
         return m_pBitmap;
     }
 
     CFX_DIBitmap*               Detach();
 
     void                                Replace(CFX_DIBitmap* pBitmap);
 private:
     CFX_DIBitmap*               m_pBitmap;
 };
 class CStretchEngine;
 class CFX_ImageStretcher
 {
 public:
-
     CFX_ImageStretcher();
-
     ~CFX_ImageStretcher();
 
-    int32_t             Start(IFX_ScanlineComposer* pDest, const CFX_DIBSource* pBitmap,
-                          int dest_width, int dest_height, const FX_RECT& bitmap_rect, FX_DWORD flags);
+    bool Start(IFX_ScanlineComposer* pDest, const CFX_DIBSource* pBitmap,
+               int dest_width, int dest_height, const FX_RECT& bitmap_rect,
+               FX_DWORD flags);
 
+    bool Continue(IFX_Pause* pPause);
+    bool StartQuickStretch();
+    bool StartStretch();
+    bool ContinueQuickStretch(IFX_Pause* pPause);
+        bool ContinueStretch(IFX_Pause* pPause);
 
-    int32_t             Continue(IFX_Pause* pPause);
     IFX_ScanlineComposer*       m_pDest;
     const CFX_DIBSource*        m_pSource;
-    CStretchEngine*             m_pStretchEngine;
+    CStretchEngine*     m_pStretchEngine;
     FX_DWORD            m_Flags;
-    FX_BOOL                     m_bFlipX,
-                    m_bFlipY;
-    int                         m_DestWidth,
-                    m_DestHeight;
+    bool                        m_bFlipX;
+    bool                        m_bFlipY;
+    int                         m_DestWidth;
+    int                         m_DestHeight;
     FX_RECT                     m_ClipRect;
     int                         m_LineIndex;
     int                         m_DestBPP;
     uint8_t*            m_pScanline;
-    uint8_t*       m_pMaskScanline;
+    uint8_t*            m_pMaskScanline;
     FXDIB_Format        m_DestFormat;
-    int32_t             m_Status;
-
-    int32_t             StartQuickStretch();
-
-    int32_t             StartStretch();
-
-    int32_t             ContinueQuickStretch(IFX_Pause* pPause);
-
-    int32_t             ContinueStretch(IFX_Pause* pPause);
+    int32_t                     m_Status;
 };
 class CFX_ImageTransformer
 {
 public:
-
     CFX_ImageTransformer();
-
     ~CFX_ImageTransformer();
 
-    int32_t     Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pMatrix, int flags, const FX_RECT* pClip);
+    bool Start(const CFX_DIBSource* pSrc, const CFX_AffineMatrix* pMatrix,
+               int flags, const FX_RECT* pClip);
 
+    bool Continue(IFX_Pause* pPause);
 
-    int32_t     Continue(IFX_Pause* pPause);
     CFX_AffineMatrix* m_pMatrix;
     FX_RECT             m_StretchClip;
-    int                 m_ResultLeft, m_ResultTop, m_ResultWidth, m_ResultHeight;
+    int                 m_ResultLeft;
+    int                 m_ResultTop;
+    int                 m_ResultWidth;
+    int                 m_ResultHeight;
     CFX_AffineMatrix    m_dest2stretch;
     CFX_ImageStretcher  m_Stretcher;
     CFX_BitmapStorer    m_Storer;
     FX_DWORD    m_Flags;
     int                 m_Status;
 };
 class CFX_ImageRenderer
 {
 public:
-
     CFX_ImageRenderer();
-
     ~CFX_ImageRenderer();
 
-    int32_t                     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 = FALSE, int alpha_flag = 0, void* pIccTransform = NULL,
-                              int blend_type = FXDIB_BLEND_NORMAL);
+    bool 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, bool bRgbByteOrder = false,
+               int alpha_flag = 0, void* pIccTransform = NULL,
+               int blend_type = FXDIB_BLEND_NORMAL);
 
-    int32_t                     Continue(IFX_Pause* pPause);
+    bool Continue(IFX_Pause* pPause);
+
 protected:
     CFX_DIBitmap*               m_pDevice;
     const CFX_ClipRgn*  m_pClipRgn;
     int                                 m_BitmapAlpha;
     FX_DWORD                    m_MaskColor;
     CFX_AffineMatrix    m_Matrix;
     CFX_ImageTransformer*       m_pTransformer;
     CFX_ImageStretcher  m_Stretcher;
     CFX_BitmapComposer  m_Composer;
     int                                 m_Status;
     int                                 m_DestLeft, m_DestTop;
     FX_RECT                             m_ClipBox;
     FX_DWORD                    m_Flags;
     int                                 m_AlphaFlag;
     void*                               m_pIccTransform;
-    FX_BOOL                             m_bRgbByteOrder;
+    bool                                m_bRgbByteOrder;
     int                                 m_BlendType;
 };
 
 #endif  // CORE_INCLUDE_FXGE_FX_DIB_H_