Remove FX_BOOL from xfa.

xfa/fxgraphics/cfx_graphics.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 "xfa/fxgraphics/cfx_graphics.h"
 
 #include <memory>
 
@@ skipping 555 matching lines @@
          0x00, 0x00, 0x00, 0x00,
      }},
 };
 
 }  // namespace
 
 CFX_Graphics::CFX_Graphics()
     : m_type(FX_CONTEXT_None), m_renderDevice(nullptr) {}
 
 FWL_Error CFX_Graphics::Create(CFX_RenderDevice* renderDevice,
-                               FX_BOOL isAntialiasing) {
+                               bool isAntialiasing) {
   if (!renderDevice)
     return FWL_Error::ParameterInvalid;
   if (m_type != FX_CONTEXT_None)
     return FWL_Error::PropertyInvalid;
 
   m_type = FX_CONTEXT_Device;
   m_info.isAntialiasing = isAntialiasing;
   m_renderDevice = renderDevice;
   if (m_renderDevice->GetDeviceCaps(FXDC_RENDER_CAPS) & FXRC_SOFT_CLIP)
     return FWL_Error::Succeeded;
   return FWL_Error::Indefinite;
 }
 
 FWL_Error CFX_Graphics::Create(int32_t width,
                                int32_t height,
                                FXDIB_Format format,
-                               FX_BOOL isNative,
-                               FX_BOOL isAntialiasing) {
+                               bool isNative,
+                               bool isAntialiasing) {
   if (m_type != FX_CONTEXT_None)
     return FWL_Error::PropertyInvalid;
 
   m_type = FX_CONTEXT_Device;
   m_info.isAntialiasing = isAntialiasing;
   m_aggGraphics.reset(new CAGG_Graphics);
   return m_aggGraphics->Create(this, width, height, format);
 }
 
 CFX_Graphics::~CFX_Graphics() {}
 
 FWL_Error CFX_Graphics::GetDeviceCap(const int32_t capID,
                                      FX_DeviceCap& capVal) {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     capVal = m_renderDevice->GetDeviceCaps(capID);
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
-FWL_Error CFX_Graphics::IsPrinterDevice(FX_BOOL& isPrinter) {
+FWL_Error CFX_Graphics::IsPrinterDevice(bool& isPrinter) {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     isPrinter = m_renderDevice->GetDeviceClass() == FXDC_PRINTER;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
-FWL_Error CFX_Graphics::EnableAntialiasing(FX_BOOL isAntialiasing) {
+FWL_Error CFX_Graphics::EnableAntialiasing(bool isAntialiasing) {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     m_info.isAntialiasing = isAntialiasing;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::SaveGraphState() {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     m_renderDevice->SaveState();
@@ skipping 120 matching lines @@
 }
 
 FWL_Error CFX_Graphics::GetLineWidth(FX_FLOAT& lineWidth) const {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     lineWidth = m_info.graphState.m_LineWidth;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
-FWL_Error CFX_Graphics::SetLineWidth(FX_FLOAT lineWidth, FX_BOOL isActOnDash) {
+FWL_Error CFX_Graphics::SetLineWidth(FX_FLOAT lineWidth, bool isActOnDash) {
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     m_info.graphState.m_LineWidth = lineWidth;
     m_info.isActOnDash = isActOnDash;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::GetStrokeAlignment(
     FX_StrokeAlignment& strokeAlignment) const {
@@ skipping 49 matching lines @@
     return RenderDeviceFillPath(path, fillMode, matrix);
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::ClipPath(CFX_Path* path,
                                  FX_FillMode fillMode,
                                  CFX_Matrix* matrix) {
   if (!path)
     return FWL_Error::ParameterInvalid;
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
-    FX_BOOL result =
+    bool result =
         m_renderDevice->SetClip_PathFill(path->GetPathData(), matrix, fillMode);
     if (!result)
       return FWL_Error::Indefinite;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::DrawImage(CFX_DIBSource* source,
                                   const CFX_PointF& point,
@@ skipping 104 matching lines @@
 FWL_Error CFX_Graphics::ShowText(const CFX_PointF& point,
                                  const CFX_WideString& text,
                                  CFX_Matrix* matrix) {
   if (m_type == FX_CONTEXT_Device && m_renderDevice)
     return RenderDeviceShowText(point, text, matrix);
   return FWL_Error::PropertyInvalid;
 }
 
 void CFX_Graphics::CalcTextRect(CFX_RectF& rect,
                                 const CFX_WideString& text,
-                                FX_BOOL isMultiline,
+                                bool isMultiline,
                                 CFX_Matrix* matrix) {
   if (m_type != FX_CONTEXT_Device || !m_renderDevice)
     return;
 
   int32_t length = text.GetLength();
   uint32_t* charCodes = FX_Alloc(uint32_t, length);
   FXTEXT_CHARPOS* charPos = FX_Alloc(FXTEXT_CHARPOS, length);
   CalcTextInfo(text, charCodes, charPos, rect);
   FX_Free(charPos);
   FX_Free(charCodes);
 }
 
 FWL_Error CFX_Graphics::Transfer(CFX_Graphics* graphics,
                                  const CFX_Matrix* matrix) {
   if (!graphics || !graphics->m_renderDevice)
     return FWL_Error::ParameterInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     CFX_DIBitmap* bitmap = graphics->m_renderDevice->GetBitmap();
-    FX_BOOL result = m_renderDevice->SetDIBits(bitmap, 0, 0);
+    bool result = m_renderDevice->SetDIBits(bitmap, 0, 0);
     if (!result)
       return FWL_Error::MethodNotSupported;
     return FWL_Error::Succeeded;
   }
   return FWL_Error::PropertyInvalid;
 }
 
 FWL_Error CFX_Graphics::Transfer(CFX_Graphics* graphics,
                                  FX_FLOAT srcLeft,
                                  FX_FLOAT srcTop,
                                  const CFX_RectF& dstRect,
                                  const CFX_Matrix* matrix) {
   if (!graphics || !graphics->m_renderDevice)
     return FWL_Error::ParameterInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   if (m_type == FX_CONTEXT_Device && m_renderDevice) {
     CFX_DIBitmap bmp;
-    FX_BOOL result =
+    bool result =
         bmp.Create((int32_t)dstRect.width, (int32_t)dstRect.height,
                    graphics->m_renderDevice->GetBitmap()->GetFormat());
     if (!result)
       return FWL_Error::IntermediateValueInvalid;
     result = graphics->m_renderDevice->GetDIBits(&bmp, (int32_t)srcLeft,
                                                  (int32_t)srcTop);
     if (!result)
       return FWL_Error::MethodNotSupported;
     result = m_renderDevice->SetDIBits(&bmp, (int32_t)dstRect.left,
                                        (int32_t)dstRect.top);
@@ skipping 145 matching lines @@
   if (!m_info.strokeColor)
     return FWL_Error::PropertyInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   switch (m_info.strokeColor->m_type) {
     case FX_COLOR_Solid: {
-      FX_BOOL result =
+      bool result =
           m_renderDevice->DrawPath(path->GetPathData(), &m, &m_info.graphState,
                                    0x0, m_info.strokeColor->m_info.argb, 0);
       if (!result)
         return FWL_Error::Indefinite;
       return FWL_Error::Succeeded;
     }
     case FX_COLOR_Pattern:
       return StrokePathWithPattern(path, &m);
     case FX_COLOR_Shading:
       return StrokePathWithShading(path, &m);
     default:
       return FWL_Error::PropertyInvalid;
   }
 }
 
 FWL_Error CFX_Graphics::RenderDeviceFillPath(CFX_Path* path,
                                              FX_FillMode fillMode,
                                              CFX_Matrix* matrix) {
   if (!m_info.fillColor)
     return FWL_Error::PropertyInvalid;
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   if (matrix) {
     m.Concat(*matrix);
   }
   switch (m_info.fillColor->m_type) {
     case FX_COLOR_Solid: {
-      FX_BOOL result = m_renderDevice->DrawPath(
+      bool result = m_renderDevice->DrawPath(
           path->GetPathData(), &m, &m_info.graphState,
           m_info.fillColor->m_info.argb, 0x0, fillMode);
       if (!result)
         return FWL_Error::Indefinite;
       return FWL_Error::Succeeded;
     }
     case FX_COLOR_Pattern:
       return FillPathWithPattern(path, fillMode, &m);
     case FX_COLOR_Shading:
       return FillPathWithShading(path, fillMode, &m);
     default:
       return FWL_Error::PropertyInvalid;
   }
 }
 
 FWL_Error CFX_Graphics::RenderDeviceDrawImage(CFX_DIBSource* source,
                                               const CFX_PointF& point,
                                               CFX_Matrix* matrix) {
   CFX_Matrix m1;
   m1.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
          m_info.CTM.f);
   if (matrix) {
     m1.Concat(*matrix);
   }
   CFX_Matrix m2;
   m2.Set((FX_FLOAT)source->GetWidth(), 0.0, 0.0, (FX_FLOAT)source->GetHeight(),
          point.x, point.y);
   m2.Concat(m1);
   int32_t left, top;
-  std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(FALSE, TRUE));
+  std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(false, true));
   std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->TransformTo(&m2, left, top));
   CFX_RectF r;
   GetClipRect(r);
   CFX_DIBitmap* bitmap = m_renderDevice->GetBitmap();
   CFX_DIBitmap bmp;
   if (bmp.Create(bitmap->GetWidth(), bitmap->GetHeight(), FXDIB_Argb) &&
       m_renderDevice->GetDIBits(&bmp, 0, 0) &&
       bmp.TransferBitmap(FXSYS_round(r.left), FXSYS_round(r.top),
                          FXSYS_round(r.Width()), FXSYS_round(r.Height()),
                          bmp2.get(), FXSYS_round(r.left - left),
@@ skipping 12 matching lines @@
          m_info.CTM.f);
   if (matrix) {
     m1.Concat(*matrix);
   }
   std::unique_ptr<CFX_DIBitmap> bmp1(
       source->StretchTo((int32_t)rect.Width(), (int32_t)rect.Height()));
   CFX_Matrix m2;
   m2.Set(rect.Width(), 0.0, 0.0, rect.Height(), rect.left, rect.top);
   m2.Concat(m1);
   int32_t left, top;
-  std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->FlipImage(FALSE, TRUE));
+  std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->FlipImage(false, true));
   std::unique_ptr<CFX_DIBitmap> bmp3(bmp2->TransformTo(&m2, left, top));
   CFX_RectF r;
   GetClipRect(r);
   CFX_DIBitmap* bitmap = m_renderDevice->GetBitmap();
   if (bitmap->CompositeBitmap(FXSYS_round(r.left), FXSYS_round(r.top),
                               FXSYS_round(r.Width()), FXSYS_round(r.Height()),
                               bmp3.get(), FXSYS_round(r.left - left),
                               FXSYS_round(r.top - top))) {
     return FWL_Error::Succeeded;
   }
   return FWL_Error::Indefinite;
 }
 
 FWL_Error CFX_Graphics::RenderDeviceShowText(const CFX_PointF& point,
                                              const CFX_WideString& text,
                                              CFX_Matrix* matrix) {
   int32_t length = text.GetLength();
   uint32_t* charCodes = FX_Alloc(uint32_t, length);
   FXTEXT_CHARPOS* charPos = FX_Alloc(FXTEXT_CHARPOS, length);
   CFX_RectF rect;
   rect.Set(point.x, point.y, 0, 0);
   CalcTextInfo(text, charCodes, charPos, rect);
   CFX_Matrix m;
   m.Set(m_info.CTM.a, m_info.CTM.b, m_info.CTM.c, m_info.CTM.d, m_info.CTM.e,
         m_info.CTM.f);
   m.Translate(0, m_info.fontSize * m_info.fontHScale);
   if (matrix) {
     m.Concat(*matrix);
   }
-  FX_BOOL result = m_renderDevice->DrawNormalText(
+  bool result = m_renderDevice->DrawNormalText(
       length, charPos, m_info.font, -m_info.fontSize * m_info.fontHScale, &m,
       m_info.fillColor->m_info.argb, FXTEXT_CLEARTYPE);
   if (!result)
     return FWL_Error::Indefinite;
   FX_Free(charPos);
   FX_Free(charCodes);
   return FWL_Error::Succeeded;
 }
 
 FWL_Error CFX_Graphics::StrokePathWithPattern(CFX_Path* path,
@@ skipping 173 matching lines @@
 FWL_Error CFX_Graphics::SetDIBitsWithMatrix(CFX_DIBSource* source,
                                             CFX_Matrix* matrix) {
   if (matrix->IsIdentity()) {
     m_renderDevice->SetDIBits(source, 0, 0);
   } else {
     CFX_Matrix m;
     m.Set((FX_FLOAT)source->GetWidth(), 0, 0, (FX_FLOAT)source->GetHeight(), 0,
           0);
     m.Concat(*matrix);
     int32_t left, top;
-    std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(FALSE, TRUE));
+    std::unique_ptr<CFX_DIBitmap> bmp1(source->FlipImage(false, true));
     std::unique_ptr<CFX_DIBitmap> bmp2(bmp1->TransformTo(&m, left, top));
     m_renderDevice->SetDIBits(bmp2.get(), left, top);
   }
   return FWL_Error::Succeeded;
 }
 
 FWL_Error CFX_Graphics::CalcTextInfo(const CFX_WideString& text,
                                      uint32_t* charCodes,
                                      FXTEXT_CHARPOS* charPos,
                                      CFX_RectF& rect) {
   std::unique_ptr<CFX_UnicodeEncoding> encoding(
       new CFX_UnicodeEncoding(m_info.font));
   int32_t length = text.GetLength();
   FX_FLOAT penX = (FX_FLOAT)rect.left;
   FX_FLOAT penY = (FX_FLOAT)rect.top;
   FX_FLOAT left = (FX_FLOAT)(0);
   FX_FLOAT top = (FX_FLOAT)(0);
   charCodes[0] = text.GetAt(0);
   charPos[0].m_OriginX = penX + left;
   charPos[0].m_OriginY = penY + top;
   charPos[0].m_GlyphIndex = encoding->GlyphFromCharCode(charCodes[0]);
   charPos[0].m_FontCharWidth = FXSYS_round(
       m_info.font->GetGlyphWidth(charPos[0].m_GlyphIndex) * m_info.fontHScale);
-  charPos[0].m_bGlyphAdjust = TRUE;
+  charPos[0].m_bGlyphAdjust = true;
   charPos[0].m_AdjustMatrix[0] = -1;
   charPos[0].m_AdjustMatrix[1] = 0;
   charPos[0].m_AdjustMatrix[2] = 0;
   charPos[0].m_AdjustMatrix[3] = 1;
   penX += (FX_FLOAT)(charPos[0].m_FontCharWidth) * m_info.fontSize / 1000 +
           m_info.fontSpacing;
   for (int32_t i = 1; i < length; i++) {
     charCodes[i] = text.GetAt(i);
     charPos[i].m_OriginX = penX + left;
     charPos[i].m_OriginY = penY + top;
     charPos[i].m_GlyphIndex = encoding->GlyphFromCharCode(charCodes[i]);
     charPos[i].m_FontCharWidth =
         FXSYS_round(m_info.font->GetGlyphWidth(charPos[i].m_GlyphIndex) *
                     m_info.fontHScale);
-    charPos[i].m_bGlyphAdjust = TRUE;
+    charPos[i].m_bGlyphAdjust = true;
     charPos[i].m_AdjustMatrix[0] = -1;
     charPos[i].m_AdjustMatrix[1] = 0;
     charPos[i].m_AdjustMatrix[2] = 0;
     charPos[i].m_AdjustMatrix[3] = 1;
     penX += (FX_FLOAT)(charPos[i].m_FontCharWidth) * m_info.fontSize / 1000 +
             m_info.fontSpacing;
   }
   rect.width = (FX_FLOAT)penX - rect.left;
   rect.height = rect.top + m_info.fontSize * m_info.fontHScale - rect.top;
   return FWL_Error::Succeeded;
 }
 
 CFX_Graphics::TInfo::TInfo()
-    : isAntialiasing(TRUE),
+    : isAntialiasing(true),
       strokeAlignment(FX_STROKEALIGNMENT_Center),
-      isActOnDash(FALSE),
+      isActOnDash(false),
       strokeColor(nullptr),
       fillColor(nullptr),
       font(nullptr),
       fontSize(40.0),
       fontHScale(1.0),
       fontSpacing(0.0) {}
 
 CFX_Graphics::TInfo::TInfo(const TInfo& info)
     : graphState(info.graphState),
       isAntialiasing(info.isAntialiasing),
@@ skipping 14 matching lines @@
   CTM = other.CTM;
   isActOnDash = other.isActOnDash;
   strokeColor = other.strokeColor;
   fillColor = other.fillColor;
   font = other.font;
   fontSize = other.fontSize;
   fontHScale = other.fontHScale;
   fontSpacing = other.fontSpacing;
   return *this;
 }