Remove FX_BOOL from xfa.

xfa/fde/tto/fde_textout.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/fde/tto/fde_textout.h"
 
 #include <algorithm>
 
@@ skipping 12 matching lines @@
       m_fFontSize(12.0f),
       m_fLineSpace(m_fFontSize),
       m_fLinePos(0.0f),
       m_fTolerance(0.0f),
       m_iAlignment(0),
       m_iTxtBkAlignment(0),
       m_wParagraphBkChar(L'\n'),
       m_TxtColor(0xFF000000),
       m_dwStyles(0),
       m_dwTxtBkStyles(0),
-      m_bElliChanged(FALSE),
+      m_bElliChanged(false),
       m_iEllipsisWidth(0),
       m_ttoLines(5),
       m_iCurLine(0),
       m_iCurPiece(0),
       m_iTotalLines(0) {
   m_Matrix.SetIdentity();
   m_rtClip.Reset();
   m_rtLogicClip.Reset();
 }
 
 CFDE_TextOut::~CFDE_TextOut() {
-  m_ttoLines.RemoveAll(FALSE);
+  m_ttoLines.RemoveAll(false);
 }
 
 void CFDE_TextOut::SetFont(CFGAS_GEFont* pFont) {
   ASSERT(pFont);
   m_pFont = pFont;
   m_pTxtBreak->SetFont(pFont);
 }
 
 void CFDE_TextOut::SetFontSize(FX_FLOAT fFontSize) {
   ASSERT(fFontSize > 0);
@@ skipping 25 matching lines @@
   }
   if (dwStyles & FDE_TTOSTYLE_VerticalLayout) {
     m_dwTxtBkStyles |=
         (FX_TXTLAYOUTSTYLE_VerticalChars | FX_TXTLAYOUTSTYLE_VerticalLayout);
   }
   m_pTxtBreak->SetLayoutStyles(m_dwTxtBkStyles);
 }
 
 void CFDE_TextOut::SetTabWidth(FX_FLOAT fTabWidth) {
   ASSERT(fTabWidth > 1.0f);
-  m_pTxtBreak->SetTabWidth(fTabWidth, FALSE);
+  m_pTxtBreak->SetTabWidth(fTabWidth, false);
 }
 
 void CFDE_TextOut::SetEllipsisString(const CFX_WideString& wsEllipsis) {
-  m_bElliChanged = TRUE;
+  m_bElliChanged = true;
   m_wsEllipsis = wsEllipsis;
 }
 
 void CFDE_TextOut::SetParagraphBreakChar(FX_WCHAR wch) {
   m_wParagraphBkChar = wch;
   m_pTxtBreak->SetParagraphBreakChar(wch);
 }
 
 void CFDE_TextOut::SetAlignment(int32_t iAlignment) {
   m_iAlignment = iAlignment;
@@ skipping 19 matching lines @@
   ASSERT(fLineSpace > 1.0f);
   m_fLineSpace = fLineSpace;
 }
 
 void CFDE_TextOut::SetDIBitmap(CFX_DIBitmap* pDIB) {
   ASSERT(pDIB);
 
   m_pRenderDevice.reset();
   CFX_FxgeDevice* device = new CFX_FxgeDevice;
   device->Attach(pDIB, false, nullptr, false);
-  m_pRenderDevice.reset(new CFDE_RenderDevice(device, FALSE));
+  m_pRenderDevice.reset(new CFDE_RenderDevice(device, false));
 }
 
 void CFDE_TextOut::SetRenderDevice(CFX_RenderDevice* pDevice) {
   ASSERT(pDevice);
-  m_pRenderDevice.reset(new CFDE_RenderDevice(pDevice, FALSE));
+  m_pRenderDevice.reset(new CFDE_RenderDevice(pDevice, false));
 }
 
 void CFDE_TextOut::SetClipRect(const CFX_Rect& rtClip) {
   m_rtClip.Set((FX_FLOAT)rtClip.left, (FX_FLOAT)rtClip.top,
                (FX_FLOAT)rtClip.Width(), (FX_FLOAT)rtClip.Height());
 }
 
 void CFDE_TextOut::SetClipRect(const CFX_RectF& rtClip) {
   m_rtClip = rtClip;
 }
@@ skipping 82 matching lines @@
   }
 }
 
 void CFDE_TextOut::CalcTextSize(const FX_WCHAR* pwsStr,
                                 int32_t iLength,
                                 CFX_RectF& rect) {
   ASSERT(m_pFont && m_fFontSize >= 1.0f);
   SetLineWidth(rect);
   m_iTotalLines = 0;
   const FX_WCHAR* pStr = pwsStr;
-  FX_BOOL bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+  bool bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
   FX_FLOAT fWidth = 0.0f;
   FX_FLOAT fHeight = 0.0f;
   FX_FLOAT fStartPos = bVertical ? rect.bottom() : rect.right();
   uint32_t dwBreakStatus = 0;
   FX_WCHAR wPreChar = 0;
   FX_WCHAR wch;
   FX_WCHAR wBreak = 0;
   while (iLength-- > 0) {
     wch = *pStr++;
     if (wBreak == 0 && (wch == L'\n' || wch == L'\r')) {
@@ skipping 52 matching lines @@
     } else {
       if (rect.Width() < 1.0f) {
         rect.width = m_fFontSize * 1000.0f;
       }
       fLineWidth = rect.Width();
     }
     m_pTxtBreak->SetLineWidth(fLineWidth);
   }
 }
 
-FX_BOOL CFDE_TextOut::RetrieveLineWidth(uint32_t dwBreakStatus,
-                                        FX_FLOAT& fStartPos,
-                                        FX_FLOAT& fWidth,
-                                        FX_FLOAT& fHeight) {
+bool CFDE_TextOut::RetrieveLineWidth(uint32_t dwBreakStatus,
+                                     FX_FLOAT& fStartPos,
+                                     FX_FLOAT& fWidth,
+                                     FX_FLOAT& fHeight) {
   if (dwBreakStatus <= FX_TXTBREAK_PieceBreak) {
-    return FALSE;
+    return false;
   }
   FX_FLOAT fLineStep =
       (m_fLineSpace > m_fFontSize) ? m_fLineSpace : m_fFontSize;
-  FX_BOOL bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
+  bool bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
   FX_FLOAT fLineWidth = 0.0f;
   int32_t iCount = m_pTxtBreak->CountBreakPieces();
   for (int32_t i = 0; i < iCount; i++) {
     const CFX_TxtPiece* pPiece = m_pTxtBreak->GetBreakPiece(i);
     fLineWidth += (FX_FLOAT)pPiece->m_iWidth / 20000.0f;
     fStartPos = std::min(fStartPos, (FX_FLOAT)pPiece->m_iStartPos / 20000.0f);
   }
   m_pTxtBreak->ClearBreakPieces();
   if (dwBreakStatus == FX_TXTBREAK_ParagraphBreak) {
     m_pTxtBreak->Reset();
   }
   if (!bLineWrap && dwBreakStatus == FX_TXTBREAK_LineBreak) {
     fWidth += fLineWidth;
   } else {
     fWidth = std::max(fWidth, fLineWidth);
     fHeight += fLineStep;
   }
   m_iTotalLines++;
-  return TRUE;
+  return true;
 }
 
 void CFDE_TextOut::DrawText(const FX_WCHAR* pwsStr,
                             int32_t iLength,
                             int32_t x,
                             int32_t y) {
   CFX_RectF rtText;
   rtText.Set((FX_FLOAT)x, (FX_FLOAT)y, m_fFontSize * 1000.0f,
              m_fFontSize * 1000.0f);
   DrawText(pwsStr, iLength, rtText);
@@ skipping 56 matching lines @@
     return;
 
   if (rect.width < m_fFontSize || rect.height < m_fFontSize) {
     return;
   }
   FX_FLOAT fLineWidth = rect.width;
   if (m_dwStyles & FDE_TTOSTYLE_VerticalLayout) {
     fLineWidth = rect.height;
   }
   m_pTxtBreak->SetLineWidth(fLineWidth);
-  m_ttoLines.RemoveAll(TRUE);
+  m_ttoLines.RemoveAll(true);
   m_wsText.clear();
   LoadText(pwsStr, iLength, rect);
   if (m_dwStyles & FDE_TTOSTYLE_Ellipsis) {
     ReplaceWidthEllipsis();
   }
   Reload(rect);
   DoAlignment(rect);
   OnDraw(rtClip);
 }
 
@@ skipping 13 matching lines @@
       if (m_CharPos.size() < size)
         m_CharPos.resize(size, FXTEXT_CHARPOS());
       break;
   }
 }
 
 void CFDE_TextOut::LoadEllipsis() {
   if (!m_bElliChanged) {
     return;
   }
-  m_bElliChanged = FALSE;
+  m_bElliChanged = false;
   m_iEllipsisWidth = 0;
   int32_t iLength = m_wsEllipsis.GetLength();
   if (iLength < 1) {
     return;
   }
   ExpandBuffer(iLength, 1);
   const FX_WCHAR* pStr = m_wsEllipsis.c_str();
   uint32_t dwBreakStatus;
   FX_WCHAR wch;
   while (iLength-- > 0) {
@@ skipping 23 matching lines @@
   }
   m_pTxtBreak->ClearBreakPieces();
 }
 
 void CFDE_TextOut::LoadText(const FX_WCHAR* pwsStr,
                             int32_t iLength,
                             const CFX_RectF& rect) {
   FX_WCHAR* pStr = m_wsText.GetBuffer(iLength);
   int32_t iTxtLength = iLength;
   ExpandBuffer(iTxtLength, 0);
-  FX_BOOL bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
-  FX_BOOL bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
+  bool bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+  bool bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
   FX_FLOAT fLineStep =
       (m_fLineSpace > m_fFontSize) ? m_fLineSpace : m_fFontSize;
   FX_FLOAT fLineStop = bVertical ? rect.left : rect.bottom();
   m_fLinePos = bVertical ? rect.right() : rect.top;
   if (bVertical) {
     fLineStep = -fLineStep;
   }
   m_hotKeys.RemoveAll();
   int32_t iStartChar = 0;
   int32_t iChars = 0;
   int32_t iPieceWidths = 0;
   uint32_t dwBreakStatus;
   FX_WCHAR wch;
-  FX_BOOL bRet = FALSE;
+  bool bRet = false;
   while (iTxtLength-- > 0) {
     wch = *pwsStr++;
     if (bHotKey && wch == L'&' && *(pStr - 1) != L'&') {
       if (iTxtLength > 0)
         m_hotKeys.Add(iChars);
       continue;
     }
     *pStr++ = wch;
     iChars++;
     dwBreakStatus = m_pTxtBreak->AppendChar(wch);
     if (dwBreakStatus > FX_TXTBREAK_PieceBreak) {
-      FX_BOOL bEndofLine =
-          RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, FALSE, rect);
+      bool bEndofLine =
+          RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, false, rect);
       if (bEndofLine && (bLineWrap || (dwBreakStatus > FX_TXTBREAK_LineBreak &&
                                        !bLineWrap))) {
         iPieceWidths = 0;
         m_iCurLine++;
         m_fLinePos += fLineStep;
       }
       if ((bVertical && m_fLinePos + fLineStep < fLineStop) ||
           (!bVertical && m_fLinePos + fLineStep > fLineStop)) {
         int32_t iCurLine = m_iCurLine;
         if (bEndofLine) {
           iCurLine--;
         }
         CFDE_TTOLine* pLine = m_ttoLines.GetPtrAt(iCurLine);
-        pLine->m_bNewReload = TRUE;
-        bRet = TRUE;
+        pLine->m_bNewReload = true;
+        bRet = true;
         break;
       }
     }
   }
   dwBreakStatus = m_pTxtBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
   if (dwBreakStatus > FX_TXTBREAK_PieceBreak && !bRet) {
-    RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, FALSE, rect);
+    RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, false, rect);
   }
   m_pTxtBreak->ClearBreakPieces();
   m_pTxtBreak->Reset();
   m_wsText.ReleaseBuffer(iLength);
 }
 
-FX_BOOL CFDE_TextOut::RetriecePieces(uint32_t dwBreakStatus,
-                                     int32_t& iStartChar,
-                                     int32_t& iPieceWidths,
-                                     FX_BOOL bReload,
-                                     const CFX_RectF& rect) {
-  FX_BOOL bSingleLine = !!(m_dwStyles & FDE_TTOSTYLE_SingleLine);
-  FX_BOOL bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+bool CFDE_TextOut::RetriecePieces(uint32_t dwBreakStatus,
+                                  int32_t& iStartChar,
+                                  int32_t& iPieceWidths,
+                                  bool bReload,
+                                  const CFX_RectF& rect) {
+  bool bSingleLine = !!(m_dwStyles & FDE_TTOSTYLE_SingleLine);
+  bool bLineWrap = !!(m_dwStyles & FDE_TTOSTYLE_LineWrap);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
   FX_FLOAT fLineStep =
       (m_fLineSpace > m_fFontSize) ? m_fLineSpace : m_fFontSize;
   if (bVertical) {
     fLineStep = -fLineStep;
   }
   CFX_Char* pTC = nullptr;
-  FX_BOOL bNeedReload = FALSE;
+  bool bNeedReload = false;
   FX_FLOAT fLineWidth = bVertical ? rect.Height() : rect.Width();
   int32_t iLineWidth = FXSYS_round(fLineWidth * 20000.0f);
   int32_t iCount = m_pTxtBreak->CountBreakPieces();
   for (int32_t i = 0; i < iCount; i++) {
     const CFX_TxtPiece* pPiece = m_pTxtBreak->GetBreakPiece(i);
     int32_t iPieceChars = pPiece->GetLength();
     int32_t iChar = iStartChar;
     int32_t iWidth = 0;
     int32_t j = 0;
     for (; j < iPieceChars; j++) {
       pTC = pPiece->GetCharPtr(j);
       int32_t iCurCharWidth = pTC->m_iCharWidth > 0 ? pTC->m_iCharWidth : 0;
       if (bSingleLine || !bLineWrap) {
         if (iLineWidth - iPieceWidths - iWidth < iCurCharWidth) {
-          bNeedReload = TRUE;
+          bNeedReload = true;
           break;
         }
       }
       iWidth += iCurCharWidth;
       m_CharWidths[iChar++] = iCurCharWidth;
     }
     if (j == 0 && !bReload) {
       CFDE_TTOLine* pLine = m_ttoLines.GetPtrAt(m_iCurLine);
-      pLine->m_bNewReload = TRUE;
+      pLine->m_bNewReload = true;
     } else if (j > 0) {
       CFX_RectF rtPiece;
       if (bVertical) {
         rtPiece.left = m_fLinePos;
         rtPiece.top = rect.top + (FX_FLOAT)pPiece->m_iStartPos / 20000.0f;
         rtPiece.width = fLineStep;
         rtPiece.height = iWidth / 20000.0f;
       } else {
         rtPiece.left = rect.left + (FX_FLOAT)pPiece->m_iStartPos / 20000.0f;
         rtPiece.top = m_fLinePos;
         rtPiece.width = iWidth / 20000.0f;
         rtPiece.height = fLineStep;
       }
       FDE_TTOPIECE ttoPiece;
       ttoPiece.iStartChar = iStartChar;
       ttoPiece.iChars = j;
       ttoPiece.rtPiece = rtPiece;
       ttoPiece.dwCharStyles = pPiece->m_dwCharStyles;
       if (FX_IsOdd(pPiece->m_iBidiLevel)) {
         ttoPiece.dwCharStyles |= FX_TXTCHARSTYLE_OddBidiLevel;
       }
       AppendPiece(ttoPiece, bNeedReload, (bReload && i == iCount - 1));
     }
     iStartChar += iPieceChars;
     iPieceWidths += iWidth;
   }
   m_pTxtBreak->ClearBreakPieces();
-  FX_BOOL bRet = bSingleLine || bLineWrap || (!bLineWrap && bNeedReload) ||
-                 dwBreakStatus == FX_TXTBREAK_ParagraphBreak;
+  bool bRet = bSingleLine || bLineWrap || (!bLineWrap && bNeedReload) ||
+              dwBreakStatus == FX_TXTBREAK_ParagraphBreak;
   return bRet;
 }
 
 void CFDE_TextOut::AppendPiece(const FDE_TTOPIECE& ttoPiece,
-                               FX_BOOL bNeedReload,
-                               FX_BOOL bEnd) {
+                               bool bNeedReload,
+                               bool bEnd) {
   if (m_iCurLine >= m_ttoLines.GetSize()) {
     CFDE_TTOLine ttoLine;
     ttoLine.m_bNewReload = bNeedReload;
     m_iCurPiece = ttoLine.AddPiece(m_iCurPiece, ttoPiece);
     m_iCurLine = m_ttoLines.Add(ttoLine);
   } else {
     CFDE_TTOLine* pLine = m_ttoLines.GetPtrAt(m_iCurLine);
     pLine->m_bNewReload = bNeedReload;
     m_iCurPiece = pLine->AddPiece(m_iCurPiece, ttoPiece);
     if (bEnd) {
@@ skipping 60 matching lines @@
       continue;
 
     m_iCurLine = i;
     m_iCurPiece = 0;
     ReloadLinePiece(pLine, rect);
   }
 }
 
 void CFDE_TextOut::ReloadLinePiece(CFDE_TTOLine* pLine, const CFX_RectF& rect) {
   const FX_WCHAR* pwsStr = m_wsText.c_str();
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
   int32_t iPieceWidths = 0;
   FDE_TTOPIECE* pPiece = pLine->GetPtrAt(0);
   int32_t iStartChar = pPiece->iStartChar;
   m_fLinePos = bVertical ? pPiece->rtPiece.left : pPiece->rtPiece.top;
   int32_t iPieceCount = pLine->GetSize();
   int32_t iPieceIndex = 0;
   uint32_t dwBreakStatus = 0;
   FX_WCHAR wch;
   while (iPieceIndex < iPieceCount) {
     int32_t iStar = iStartChar;
     int32_t iEnd = pPiece->iChars + iStar;
     while (iStar < iEnd) {
       wch = *(pwsStr + iStar);
       dwBreakStatus = m_pTxtBreak->AppendChar(wch);
       if (dwBreakStatus > FX_TXTBREAK_PieceBreak) {
-        RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, TRUE, rect);
+        RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, true, rect);
       }
       iStar++;
     }
     iPieceIndex++;
     pPiece = pLine->GetPtrAt(iPieceIndex);
   }
   dwBreakStatus = m_pTxtBreak->EndBreak(FX_TXTBREAK_ParagraphBreak);
   if (dwBreakStatus > FX_TXTBREAK_PieceBreak) {
-    RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, TRUE, rect);
+    RetriecePieces(dwBreakStatus, iStartChar, iPieceWidths, true, rect);
   }
   m_pTxtBreak->Reset();
 }
 
 void CFDE_TextOut::DoAlignment(const CFX_RectF& rect) {
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
   FX_FLOAT fLineStopS = bVertical ? rect.right() : rect.bottom();
   int32_t iLines = m_ttoLines.GetSize();
   if (iLines < 1)
     return;
   FDE_TTOPIECE* pFirstPiece = m_ttoLines.GetPtrAt(iLines - 1)->GetPtrAt(0);
   if (!pFirstPiece)
     return;
 
   FX_FLOAT fLineStopD =
       bVertical ? pFirstPiece->rtPiece.right() : pFirstPiece->rtPiece.bottom();
@@ skipping 75 matching lines @@
   tr.pFont = m_pFont;
   tr.fFontSize = m_fFontSize;
   tr.dwStyles = m_dwTxtBkStyles;
   tr.dwCharStyles = pPiece->dwCharStyles;
   tr.wLineBreakChar = m_wParagraphBkChar;
   tr.pRect = &pPiece->rtPiece;
   return tr;
 }
 
 void CFDE_TextOut::DrawLine(const FDE_TTOPIECE* pPiece, CFDE_Pen*& pPen) {
-  FX_BOOL bUnderLine = !!(m_dwStyles & FDE_TTOSTYLE_Underline);
-  FX_BOOL bStrikeOut = !!(m_dwStyles & FDE_TTOSTYLE_Strikeout);
-  FX_BOOL bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
-  FX_BOOL bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
+  bool bUnderLine = !!(m_dwStyles & FDE_TTOSTYLE_Underline);
+  bool bStrikeOut = !!(m_dwStyles & FDE_TTOSTYLE_Strikeout);
+  bool bHotKey = !!(m_dwStyles & FDE_TTOSTYLE_HotKey);
+  bool bVertical = !!(m_dwStyles & FDE_TTOSTYLE_VerticalLayout);
   if (!bUnderLine && !bStrikeOut && !bHotKey)
     return;
 
   if (!pPen) {
     pPen = new CFDE_Pen;
     pPen->SetColor(m_TxtColor);
   }
   std::unique_ptr<CFDE_Path> pPath(new CFDE_Path);
   int32_t iLineCount = 0;
   CFX_RectF rtText = pPiece->rtPiece;
@@ skipping 52 matching lines @@
           iLineCount++;
         }
       }
     }
   }
   if (iLineCount > 0)
     m_pRenderDevice->DrawPath(pPen, 1, pPath.get(), &m_Matrix);
 }
 
 CFDE_TTOLine::CFDE_TTOLine()
-    : m_bNewReload(FALSE), m_pieces(5), m_iPieceCount(0) {}
+    : m_bNewReload(false), m_pieces(5), m_iPieceCount(0) {}
 
 CFDE_TTOLine::CFDE_TTOLine(const CFDE_TTOLine& ttoLine) : m_pieces(5) {
   m_bNewReload = ttoLine.m_bNewReload;
   m_iPieceCount = ttoLine.m_iPieceCount;
   m_pieces.Copy(ttoLine.m_pieces, 0, -1);
 }
 
 CFDE_TTOLine::~CFDE_TTOLine() {}
 
 int32_t CFDE_TTOLine::AddPiece(int32_t index, const FDE_TTOPIECE& ttoPiece) {
@@ skipping 15 matching lines @@
   if (index >= m_iPieceCount) {
     return nullptr;
   }
   return m_pieces.GetPtrAt(index);
 }
 
 void CFDE_TTOLine::RemoveLast(int32_t iCount) {
   m_pieces.RemoveLast(iCount);
 }
 
-void CFDE_TTOLine::RemoveAll(FX_BOOL bLeaveMemory) {
+void CFDE_TTOLine::RemoveAll(bool bLeaveMemory) {
   m_pieces.RemoveAll(bLeaveMemory);
 }